Update Crashpad to b35ee1fca18956f3c27ba124d6dc456a723c7670

third_party/crashpad/crashpad/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 29 matching lines @@
 
 namespace {
 
 const char kWriteDirectory[] = "new";
 const char kUploadPendingDirectory[] = "pending";
 const char kCompletedDirectory[] = "completed";
 
 const char kSettings[] = "settings.dat";
 
 const char* const kReportDirectories[] = {
-  kWriteDirectory,
-  kUploadPendingDirectory,
-  kCompletedDirectory,
+    kWriteDirectory,
+    kUploadPendingDirectory,
+    kCompletedDirectory,
 };
 
 const char kCrashReportFileExtension[] = "dmp";
 
 const char kXattrUUID[] = "uuid";
 const char kXattrCollectorID[] = "id";
 const char kXattrCreationTime[] = "creation_time";
 const char kXattrIsUploaded[] = "uploaded";
 const char kXattrLastUploadTime[] = "last_upload_time";
 const char kXattrUploadAttemptCount[] = "upload_count";
+const char kXattrIsUploadExplicitlyRequested[] = "upload_explicitly_requested";
 
 const char kXattrDatabaseInitialized[] = "initialized";
 
 // Ensures that the node at |path| is a directory. If the |path| refers to a
 // file, rather than a directory, returns false. Otherwise, returns true,
 // indicating that |path| already was a directory.
 bool EnsureDirectoryExists(const base::FilePath& path) {
   struct stat st;
   if (stat(path.value().c_str(), &st) != 0) {
     PLOG(ERROR) << "stat " << path.value();
@@ skipping 60 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;
+  OperationStatus RequestUpload(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 41 matching lines @@
   OperationStatus ReportsInDirectory(const base::FilePath& path,
                                      std::vector<Report>* reports);
 
   //! \brief Creates a database xattr name from the short constant name.
   //!
   //! \param[in] name The short name of the extended attribute.
   //!
   //! \return The long name of the extended attribute.
   std::string XattrName(const base::StringPiece& name);
 
+  //! \brief Marks a report with a given path as completed.
+  //!
+  //! Assumes that the report is locked.
+  //!
+  //! \param[in] report_path The path of the file to mark completed.
+  //! \param[out] out_path The path of the new file. This parameter is optional.
+  //!
+  //! \return The operation status code.
+  CrashReportDatabase::OperationStatus MarkReportCompletedLocked(
+      const base::FilePath& report_path,
+      base::FilePath* out_path);
+
   base::FilePath base_dir_;
   Settings settings_;
   bool xattr_new_names_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseMac);
 };
 
 CrashReportDatabaseMac::CrashReportDatabaseMac(const base::FilePath& path)
     : CrashReportDatabase(),
@@ skipping 228 matching lines @@
     return kReportNotFound;
 
   std::unique_ptr<const UploadReport> upload_report(
       static_cast<const UploadReport*>(report));
 
   base::ScopedFD lock(upload_report->lock_fd);
   if (!lock.is_valid())
     return kBusyError;
 
   if (successful) {
-    base::FilePath new_path =
-        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;
-    }
-    report_path = new_path;
+    CrashReportDatabase::OperationStatus os =
+        MarkReportCompletedLocked(report_path, &report_path);
+    if (os != kNoError)
+      return os;
   }
 
   if (!WriteXattrBool(report_path, XattrName(kXattrIsUploaded), successful)) {
     return kDatabaseError;
   }
   if (!WriteXattr(report_path, XattrName(kXattrCollectorID), id)) {
     return kDatabaseError;
   }
 
   time_t now = time(nullptr);
@@ skipping 23 matching lines @@
   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;
 
-  base::FilePath new_path =
-      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;
+  return MarkReportCompletedLocked(report_path, nullptr);
 }
 
 CrashReportDatabase::OperationStatus CrashReportDatabaseMac::DeleteReport(
     const UUID& uuid) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   base::FilePath report_path = LocateCrashReport(uuid);
   if (report_path.empty())
     return kReportNotFound;
 
@@ skipping 27 matching lines @@
     if (ReadXattr(path, XattrName(kXattrUUID),
                   &uuid_string) == XattrStatus::kOK &&
         uuid_string == target_uuid) {
       return path;
     }
   }
 
   return base::FilePath();
 }
 
+CrashReportDatabase::OperationStatus CrashReportDatabaseMac::RequestUpload(
+    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;
+
+  // If the crash report has already been uploaded, don't request new upload.
+  bool uploaded = false;
+  XattrStatus status =
+      ReadXattrBool(report_path, XattrName(kXattrIsUploaded), &uploaded);
+  if (status == XattrStatus::kOtherError)
+    return kDatabaseError;
+  if (uploaded)
+    return kCannotRequestUpload;
+
+  // Mark the crash report as having upload explicitly requested by the user,
+  // and move it to the pending state.
+  if (!WriteXattrBool(
+          report_path, XattrName(kXattrIsUploadExplicitlyRequested), true)) {
+    return kDatabaseError;
+  }
+
+  base::FilePath new_path =
+      base_dir_.Append(kUploadPendingDirectory).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;
+}
+
 // static
 base::ScopedFD CrashReportDatabaseMac::ObtainReportLock(
     const base::FilePath& path) {
   int fd = HANDLE_EINTR(open(path.value().c_str(),
                              O_RDONLY | O_EXLOCK | O_NONBLOCK));
   PLOG_IF(ERROR, fd < 0) << "open lock " << path.value();
   return base::ScopedFD(fd);
 }
 
 bool CrashReportDatabaseMac::ReadReportMetadataLocked(
@@ skipping 28 matching lines @@
           XattrStatus::kOtherError) {
     return false;
   }
 
   report->upload_attempts = 0;
   if (ReadXattrInt(path, XattrName(kXattrUploadAttemptCount),
                    &report->upload_attempts) == XattrStatus::kOtherError) {
     return false;
   }
 
+  report->upload_explicitly_requested = false;
+  if (ReadXattrBool(path,
+                    XattrName(kXattrIsUploadExplicitlyRequested),
+                    &report->upload_explicitly_requested) ==
+      XattrStatus::kOtherError) {
+    return false;
+  }
+
   return true;
 }
 
 CrashReportDatabase::OperationStatus CrashReportDatabaseMac::ReportsInDirectory(
     const base::FilePath& path,
     std::vector<CrashReportDatabase::Report>* reports) {
   base::mac::ScopedNSAutoreleasePool pool;
 
   DCHECK(reports->empty());
 
@@ skipping 23 matching lines @@
     reports->push_back(report);
   }
 
   return kNoError;
 }
 
 std::string CrashReportDatabaseMac::XattrName(const base::StringPiece& name) {
   return XattrNameInternal(name, xattr_new_names_);
 }
 
+CrashReportDatabase::OperationStatus
+CrashReportDatabaseMac::MarkReportCompletedLocked(
+    const base::FilePath& report_path,
+    base::FilePath* out_path) {
+  if (RemoveXattr(report_path, XattrName(kXattrIsUploadExplicitlyRequested)) ==
+      XattrStatus::kOtherError) {
+    return kDatabaseError;
+  }
+
+  base::FilePath new_path =
+      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;
+  }
+
+  if (out_path)
+    *out_path = new_path;
+  return kNoError;
+}
+
 std::unique_ptr<CrashReportDatabase> InitializeInternal(
     const base::FilePath& path,
     bool may_create) {
   std::unique_ptr<CrashReportDatabaseMac> database_mac(
       new CrashReportDatabaseMac(path));
   if (!database_mac->Initialize(may_create))
     database_mac.reset();
 
   return std::unique_ptr<CrashReportDatabase>(database_mac.release());
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
     const base::FilePath& path) {
   return InitializeInternal(path, true);
 }
 
 // static
 std::unique_ptr<CrashReportDatabase>
 CrashReportDatabase::InitializeWithoutCreating(const base::FilePath& path) {
   return InitializeInternal(path, false);
 }
 
 }  // namespace crashpad