Allow disabling upload rate-limiting

handler/crash_report_upload_thread.cc

 // 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 119 matching lines @@
  private:
   CrashReportDatabase* database_;  // weak
   const CrashReportDatabase::Report* report_;  // weak
 
   DISALLOW_COPY_AND_ASSIGN(CallRecordUploadAttempt);
 };
 
 }  // namespace
 
 CrashReportUploadThread::CrashReportUploadThread(CrashReportDatabase* database,
-                                                 const std::string& url)
+                                                 const std::string& url,
+                                                 bool rate_limit)
     : url_(url),
       // Check for pending reports every 15 minutes, even in the absence of a
       // signal from the handler thread. This allows for failed uploads to be
       // retried periodically, and for pending reports written by other
       // processes to be recognized.
       thread_(15 * 60, this),
-      database_(database) {
+      database_(database),
+      rate_limit_(rate_limit) {
 }
 
 CrashReportUploadThread::~CrashReportUploadThread() {
 }
 
 void CrashReportUploadThread::Start() {
   thread_.Start(0);
 }
 
 void CrashReportUploadThread::Stop() {
@@ skipping 39 matching lines @@
     return;
   }
 
   // This currently implements very simplistic rate-limiting, compatible with
   // the Breakpad client, where the strategy is to permit one upload attempt per
   // hour, and retire reports that would exceed this limit or for which the
   // upload fails on the first attempt.
   //
   // TODO(mark): Provide a proper rate-limiting strategy and allow for failed
   // upload attempts to be retried.
-  time_t last_upload_attempt_time;
-  if (settings->GetLastUploadAttemptTime(&last_upload_attempt_time)) {
-    time_t now = time(nullptr);
-    if (now >= last_upload_attempt_time) {
-      // If the most recent upload attempt occurred within the past hour, don’t
-      // attempt to upload the new report. If it happened longer ago, attempt to
-      // upload the report.
-      const int kUploadAttemptIntervalSeconds = 60 * 60;  // 1 hour
-      if (now - last_upload_attempt_time < kUploadAttemptIntervalSeconds) {
-        database_->SkipReportUpload(report.uuid);
-        return;
-      }
-    } else {
-      // The most recent upload attempt purportedly occurred in the future. If
-      // it “happened” at least one day in the future, assume that the last
-      // upload attempt time is bogus, and attempt to upload the report. If the
-      // most recent upload time is in the future but within one day, accept it
-      // and don’t attempt to upload the report.
-      const int kBackwardsClockTolerance = 60 * 60 * 24;  // 1 day
-      if (last_upload_attempt_time - now < kBackwardsClockTolerance) {
-        database_->SkipReportUpload(report.uuid);
-        return;
+  if (rate_limit_) {
+    time_t last_upload_attempt_time;
+    if (settings->GetLastUploadAttemptTime(&last_upload_attempt_time)) {
+      time_t now = time(nullptr);
+      if (now >= last_upload_attempt_time) {
+        // If the most recent upload attempt occurred within the past hour,
+        // don’t attempt to upload the new report. If it happened longer ago,
+        // attempt to upload the report.
+        const int kUploadAttemptIntervalSeconds = 60 * 60;  // 1 hour
+        if (now - last_upload_attempt_time < kUploadAttemptIntervalSeconds) {
+          database_->SkipReportUpload(report.uuid);
+          return;
+        }
+      } else {
+        // The most recent upload attempt purportedly occurred in the future. If
+        // it “happened” at least one day in the future, assume that the last
+        // upload attempt time is bogus, and attempt to upload the report. If
+        // the most recent upload time is in the future but within one day,
+        // accept it and don’t attempt to upload the report.
+        const int kBackwardsClockTolerance = 60 * 60 * 24;  // 1 day
+        if (last_upload_attempt_time - now < kBackwardsClockTolerance) {
+          database_->SkipReportUpload(report.uuid);
+          return;
+        }
       }
     }
   }
 
   const CrashReportDatabase::Report* upload_report;
   CrashReportDatabase::OperationStatus status =
       database_->GetReportForUploading(report.uuid, &upload_report);
   switch (status) {
     case CrashReportDatabase::kNoError:
       break;
@@ skipping 87 matching lines @@
   }
 
   return UploadResult::kSuccess;
 }
 
 void CrashReportUploadThread::DoWork(const WorkerThread* thread) {
   ProcessPendingReports();
 }
 
 }  // namespace crashpad