feat: consent-aware offline caching

client/crashpad_client.h

@@ -872,6 +872,14 @@ class CrashpadClient {
   void RemoveAttachment(const base::FilePath& attachment);
 #endif
 
+  //! \brief Requests that the handler retry pending report uploads.
+  //!
+  //! Wakes the handler's upload thread to immediately process pending reports
+  //! rather than waiting for its next periodic scan. Useful after state
+  //! changes (such as clearing UploadsPaused) that should take effect without
+  //! delay.
+  void RequestRetry();
+
  private:
 #if BUILDFLAG(IS_WIN) || DOXYGEN
   //!  \brief Registers process handlers for the client.

client/crashpad_client_linux.cc

@@ -445,6 +445,11 @@ class RequestCrashDumpHandler : public SignalHandler {
     client.RemoveAttachment(attachment);
   }
 
+  void RequestRetry() {
+    ExceptionHandlerClient client(sock_to_handler_.get(), true);
+    client.RequestRetry();
+  }
+
  private:
   RequestCrashDumpHandler() = default;
 
@@ -832,4 +837,9 @@ void CrashpadClient::RemoveAttachment(const base::FilePath& attachment) {
   signal_handler->RemoveAttachment(attachment);
 }
 
+void CrashpadClient::RequestRetry() {
+  auto signal_handler = RequestCrashDumpHandler::Get();
+  signal_handler->RequestRetry();
+}
+
 }  // namespace crashpad

client/crashpad_client_mac.cc

@@ -31,6 +31,7 @@
 #include "util/mac/mac_util.h"
 #include "util/mach/bootstrap.h"
 #include "util/mach/child_port_handshake.h"
+#include "util/mach/exception_handler_protocol.h"
 #include "util/mach/exception_ports.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
@@ -612,6 +613,11 @@ base::apple::ScopedMachSendRight CrashpadClient::GetHandlerMachPort() const {
   return base::apple::ScopedMachSendRight(exception_port_.get());
 }
 
+void CrashpadClient::RequestRetry() {
+  SendClientToServerMessage(exception_port_.get(),
+                            ClientToServerMessage::kRequestRetry);
+}
+
 // static
 void CrashpadClient::UseSystemDefaultHandler() {
   base::apple::ScopedMachSendRight system_crash_reporter_handler(

client/crashpad_client_win.cc

@@ -1231,4 +1231,11 @@ void CrashpadClient::RemoveAttachment(const base::FilePath& attachment) {
                                      &response);
 }
 
+void CrashpadClient::RequestRetry() {
+  ClientToServerMessage message = {};
+  message.type = ClientToServerMessage::kRequestRetry;
+  ServerToClientMessage response = {};
+  SendToCrashHandlerServer(ipc_pipe_, message, &response);
+}
+
 }  // namespace crashpad

client/settings.cc

@@ -126,6 +126,7 @@ struct SettingsReader::Data {
 
   enum Options : uint32_t {
     kUploadsEnabled = 1 << 0,
+    kUploadsPaused = 1 << 1,
   };
 
   Data() : magic(kSettingsMagic),
@@ -174,6 +175,17 @@ bool SettingsReader::GetUploadsEnabled(bool* enabled) {
   return true;
 }
 
+bool SettingsReader::GetUploadsPaused(bool* paused) {
+  DCHECK(initialized().is_valid());
+
+  Data settings;
+  if (!OpenAndReadSettings(&settings))
+    return false;
+
+  *paused = (settings.options & Data::Options::kUploadsPaused) != 0;
+  return true;
+}
+
 bool SettingsReader::GetLastUploadAttemptTime(time_t* time) {
   DCHECK(initialized().is_valid());
 
@@ -268,6 +280,22 @@ bool Settings::SetUploadsEnabled(bool enabled) {
   return WriteSettings(handle.get(), settings);
 }
 
+bool Settings::SetUploadsPaused(bool paused) {
+  DCHECK(initialized().is_valid());
+
+  Data settings;
+  ScopedLockedFileHandle handle = OpenForWritingAndReadSettings(&settings);
+  if (!handle.is_valid())
+    return false;
+
+  if (paused)
+    settings.options |= Data::Options::kUploadsPaused;
+  else
+    settings.options &= ~Data::Options::kUploadsPaused;
+
+  return WriteSettings(handle.get(), settings);
+}
+
 bool Settings::SetLastUploadAttemptTime(time_t time) {
   DCHECK(initialized().is_valid());
 

client/settings.h

@@ -100,6 +100,20 @@ class SettingsReader {
   //!     error logged.
   bool GetUploadsEnabled(bool* enabled);
 
+  //! \brief Retrieves whether uploads are paused.
+  //!
+  //! When paused, pending reports are retained in the `pending` state rather
+  //! than being uploaded or skipped. Reports accumulate in `pending` until the
+  //! flag is cleared, at which point normal processing resumes.
+  //!
+  //! The default value is `false`.
+  //!
+  //! \param[out] paused Whether uploads are paused.
+  //!
+  //! \return On success, returns `true`, otherwise returns `false` with an
+  //!     error logged.
+  bool GetUploadsPaused(bool* paused);
+
   //! \brief Retrieves the last time at which a report was attempted to be
   //!     uploaded.
   //!
@@ -172,6 +186,16 @@ class Settings final : public SettingsReader {
   //!     error logged.
   bool SetUploadsEnabled(bool enabled);
 
+  //! \brief Sets whether uploads are paused.
+  //!
+  //! See GetUploadsPaused() for the semantics of this flag.
+  //!
+  //! \param[in] paused Whether uploads should be paused.
+  //!
+  //! \return On success, returns `true`, otherwise returns `false` with an
+  //!     error logged.
+  bool SetUploadsPaused(bool paused);
+
   //! \brief Sets the last time at which a report was attempted to be uploaded.
   //!
   //! This is only meant to be used internally by the CrashReportDatabase.

handler/crash_report_upload_thread.cc

@@ -122,6 +122,11 @@ void CrashReportUploadThread::ReportPendingSync(const UUID& report_uuid) {
   DoWork(nullptr);
 }
 
+void CrashReportUploadThread::RetryPending() {
+  if (thread_.is_running())
+    thread_.DoWorkNow();
+}
+
 void CrashReportUploadThread::Start() {
   thread_.Start(
       options_.watch_pending_reports ? 0.0 : WorkerThread::kIndefiniteWait);
@@ -140,6 +145,14 @@ void CrashReportUploadThread::ProcessPendingReports() {
   // uploads complete (regardless of whether or not that succeeded).
   ScopedFunctionInvoker scoped_function_invoker(callback_);
 
+  bool uploads_paused;
+  if (database_->GetSettings()->GetUploadsPaused(&uploads_paused) &&
+      uploads_paused) {
+    // Leave known pending report UUIDs in the queue so they are retried once
+    // the pause is lifted, and skip scanning for new pending reports.
+    return;
+  }
+
   std::vector<UUID> known_report_uuids = known_pending_report_uuids_.Drain();
   for (const UUID& report_uuid : known_report_uuids) {
     CrashReportDatabase::Report report;

handler/crash_report_upload_thread.h

@@ -114,6 +114,15 @@ class CrashReportUploadThread : public WorkerThread::Delegate,
   //! This method will run on the pool thread executing the OnCrashDumpEvent
   void ReportPendingSync(const UUID& report_uuid);
 
+  //! \brief Wakes the upload thread to immediately process pending reports.
+  //!
+  //! Unlike ReportPending(), no specific report UUID is enqueued; the next
+  //! pass relies on the thread's pending-report scan (requires
+  //! \a watch_pending_reports).
+  //!
+  //! This method may be called from any thread.
+  void RetryPending();
+
   // Stoppable:
 
   //! \brief Starts a dedicated upload thread, which executes ThreadMain().

handler/linux/crash_report_exception_handler.cc

@@ -236,6 +236,12 @@ void CrashReportExceptionHandler::RemoveAttachment(
   attachments_.erase(it);
 }
 
+void CrashReportExceptionHandler::RequestRetry() {
+  if (upload_thread_) {
+    upload_thread_->RetryPending();
+  }
+}
+
 bool CrashReportExceptionHandler::WriteMinidumpToDatabase(
     ProcessSnapshotLinux* process_snapshot,
     ProcessSnapshotSanitized* sanitized_snapshot,

handler/linux/crash_report_exception_handler.h

@@ -100,6 +100,7 @@ class CrashReportExceptionHandler : public ExceptionHandlerServer::Delegate {
 
   void AddAttachment(const base::FilePath& attachment) override;
   void RemoveAttachment(const base::FilePath& attachment) override;
+  void RequestRetry() override;
 
  private:
   bool HandleExceptionWithConnection(

handler/linux/exception_handler_server.cc

@@ -439,6 +439,10 @@ bool ExceptionHandlerServer::ReceiveClientMessage(Event* event) {
     case ExceptionHandlerProtocol::ClientToServerMessage::kTypeRemoveAttachment:
       delegate_->RemoveAttachment(base::FilePath(message.attachment_info.path));
       return true;
+
+    case ExceptionHandlerProtocol::ClientToServerMessage::kTypeRequestRetry:
+      delegate_->RequestRetry();
+      return true;
   }
 
   DCHECK(false);

handler/linux/exception_handler_server.h

@@ -117,6 +117,10 @@ class ExceptionHandlerServer {
     //! \brief Called to remove an attachment from the crash report.
     virtual void RemoveAttachment(const base::FilePath& attachment) = 0;
 
+    //! \brief Called when the server has received a request to retry pending
+    //!     report uploads.
+    virtual void RequestRetry() = 0;
+
     virtual ~Delegate() {}
   };
 

handler/mac/crash_report_exception_handler.cc

@@ -308,4 +308,10 @@ kern_return_t CrashReportExceptionHandler::CatchMachException(
   return KERN_SUCCESS;
 }
 
+void CrashReportExceptionHandler::RequestRetry() {
+  if (upload_thread_) {
+    upload_thread_->RetryPending();
+  }
+}
+
 }  // namespace crashpad

handler/mac/crash_report_exception_handler.h

@@ -22,6 +22,7 @@
 
 #include "client/crash_report_database.h"
 #include "handler/crash_report_upload_thread.h"
+#include "handler/mac/exception_handler_server.h"
 #include "handler/user_stream_data_source.h"
 #include "util/misc/uuid.h"
 #include "util/mach/exc_server_variants.h"
@@ -31,7 +32,7 @@ namespace crashpad {
 //! \brief An exception handler that writes crash reports for exception messages
 //!     to a CrashReportDatabase.
 class CrashReportExceptionHandler final
-    : public UniversalMachExcServer::Interface {
+    : public ExceptionHandlerServer::Delegate {
  public:
   //! \brief Creates a new object that will store crash reports in \a database.
   //!
@@ -91,7 +92,11 @@ class CrashReportExceptionHandler final
       const mach_msg_trailer_t* trailer,
       bool* destroy_complex_request) override;
 
+  // ExceptionHandlerServer::Delegate:
+  void RequestRetry() override;
+
  private:
+
   CrashReportDatabase* database_;  // weak
   CrashReportUploadThread* upload_thread_;  // weak
   const std::map<std::string, std::string>* process_annotations_;  // weak