content/browser/aggregation_service/aggregatable_report_scheduler.h - chromium/src - Git at Google

 // Copyright 2022 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef CONTENT_BROWSER_AGGREGATION_SERVICE_AGGREGATABLE_REPORT_SCHEDULER_H_
 #define CONTENT_BROWSER_AGGREGATION_SERVICE_AGGREGATABLE_REPORT_SCHEDULER_H_

 #include <optional>
 #include <set>
 #include <vector>

 #include "base/functional/callback.h"
 #include "base/memory/raw_ref.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/aggregation_service/aggregation_service_storage.h"
 #include "content/browser/aggregation_service/report_scheduler_timer.h"
 #include "content/common/content_export.h"

 namespace base {
 class ElapsedTimer;
 class Time;
 }  // namespace base

 namespace content {

 class AggregatableReportRequest;
 class AggregationServiceStorageContext;

 // UI thread class that is responsible for interacting with the storage layer
 // for report requests, waiting for a report's reporting time to be reached and
 // then calling the appropriate callback.
 //
 // Note that report requests can have one of two states: "pending" or
 // "in-progress". This represents whether the request is currently being
 // processed (i.e. assembled and sent). To ensure that no report is 'lost',
 // all requests (that haven't been deleted) become pending once more on start
 // up. Note that all reports with future report times are pending (unless wall
 // clock time goes backward).
 class CONTENT_EXPORT AggregatableReportScheduler {
  public:
   // Add uniform random noise in the range of [0, 1 minutes] to the report time
   // when the browser comes back online. Aligned with
   // `AttributionStorageDelegateImpl::GetOfflineReportDelayConfig()`.
   static constexpr base::TimeDelta kOfflineReportTimeMinimumDelay =
       base::Minutes(0);
   static constexpr base::TimeDelta kOfflineReportTimeMaximumDelay =
       base::Minutes(1);

   // Configuration for retrying to send reports that failed to send
   static constexpr int kMaxRetries = 2;
   static constexpr base::TimeDelta kInitialRetryDelay = base::Minutes(5);
   static constexpr int kRetryDelayFactor = 3;

   AggregatableReportScheduler(
       AggregationServiceStorageContext* storage_context,
       base::RepeatingCallback<
           void(std::vector<AggregationServiceStorage::RequestAndId>)>
           on_scheduled_report_time_reached);

   AggregatableReportScheduler(const AggregatableReportScheduler& other) =
       delete;
   AggregatableReportScheduler& operator=(
       const AggregatableReportScheduler& other) = delete;
   virtual ~AggregatableReportScheduler();

   // Methods are virtual for testing.

   // Schedules the `request` to be assembled and sent at
   // `request.shared_info().scheduled_report_time`.
   virtual void ScheduleRequest(AggregatableReportRequest request);

   // Notifies that the request to assemble and send the report with `request_id`
   // was successfully completed. There must be an in-progress request stored
   // with that `request_id`.
   virtual void NotifyInProgressRequestSucceeded(
       AggregationServiceStorage::RequestId request_id);

   // Notifies that the request to assemble and send the report with `request_id`
   // completed unsuccessfully. There must be an in-progress request stored with
   // that `request_id`.`failed_attemps_before_sending` is the number of times
   // that this request previously failed. ie. not counting the failure being
   // notified on.
   // Returns true when the request will be scheduled to be retried.
   // Returns false when the request is dropped. ie. it wont be retried.
   virtual bool NotifyInProgressRequestFailed(
       AggregationServiceStorage::RequestId request_id,
       int previous_failed_attempts);

  private:
   class TimerDelegate : public ReportSchedulerTimer::Delegate {
    public:
     TimerDelegate(AggregationServiceStorageContext* storage_context,
                   base::RepeatingCallback<void(
                       std::vector<AggregationServiceStorage::RequestAndId>)>
                       on_scheduled_report_time_reached);
     ~TimerDelegate() override;

     TimerDelegate(const TimerDelegate&) = delete;
     TimerDelegate& operator=(const TimerDelegate&) = delete;
     TimerDelegate(TimerDelegate&&) = delete;
     TimerDelegate& operator=(TimerDelegate&&) = delete;

     // Notifies that we no longer need to track `request_id` as in-progress.
     void NotifySendAttemptCompleted(
         AggregationServiceStorage::RequestId request_id);

     base::WeakPtr<AggregatableReportScheduler::TimerDelegate> GetWeakPtr() {
       return weak_ptr_factory_.GetWeakPtr();
     }

    private:
     // ReportSchedulerTimer::Delegate:
     void GetNextReportTime(base::OnceCallback<void(std::optional<base::Time>)>,
                            base::Time now) override;
     void OnReportingTimeReached(base::Time now,
                                 base::Time timer_desired_run_time) override;
     void AdjustOfflineReportTimes(
         base::OnceCallback<void(std::optional<base::Time>)>) override;

     void OnRequestsReturnedFromStorage(
         base::ElapsedTimer task_timer,
         std::vector<AggregationServiceStorage::RequestAndId> requests_and_ids);

     // Using a raw reference is safe because `storage_context_` is guaranteed to
     // outlive `this`.
     raw_ref<AggregationServiceStorageContext> storage_context_;

     // Called when a report request's scheduled report time is reached. May
     // return multiple requests if their report times were all reached before
     // the timer fired. If multiple requests are returned, they will be ordered
     // by the report time (which may differ from the initially scheduled report
     // time).
     base::RepeatingCallback<void(
         std::vector<AggregationServiceStorage::RequestAndId>)>
         on_scheduled_report_time_reached_;

     // The set of IDs of all in-progress report requests.
     // TODO(alexmt): Consider switching to a flat_set when we have metrics on
     // the typical size.
     std::set<AggregationServiceStorage::RequestId> in_progress_requests_;

     // Set iff the private aggregation developer mode is enabled.
     bool should_not_delay_reports_;

     base::WeakPtrFactory<AggregatableReportScheduler::TimerDelegate>
         weak_ptr_factory_{this};
   };

   // Returns how long to wait before attempting to send a report that has
   // previously failed to be sent failed_send_attempts times. Returns
   // `std::nullopt` to indicate that no more attempts should be made.
   // Otherwise, the return value must be positive. `failed_send_attempts`
   // must be positive.
   static std::optional<base::TimeDelta> GetFailedReportDelay(
       int failed_send_attempts);

   // Using a raw reference is safe because `storage_context_` is guaranteed to
   // outlive `this`.
   raw_ref<AggregationServiceStorageContext> storage_context_;

   // Using a raw pointer is safe because it's owned by `timer_`. Will be cleared
   // in the destructor to avoid a dangling pointer.
   raw_ptr<TimerDelegate> timer_delegate_;

   ReportSchedulerTimer timer_;
 };

 }  // namespace content

 #endif  // CONTENT_BROWSER_AGGREGATION_SERVICE_AGGREGATABLE_REPORT_SCHEDULER_H_
	// Copyright 2022 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef CONTENT_BROWSER_AGGREGATION_SERVICE_AGGREGATABLE_REPORT_SCHEDULER_H_
	#define CONTENT_BROWSER_AGGREGATION_SERVICE_AGGREGATABLE_REPORT_SCHEDULER_H_

	#include <optional>
	#include <set>
	#include <vector>

	#include "base/functional/callback.h"
	#include "base/memory/raw_ref.h"
	#include "base/memory/weak_ptr.h"
	#include "base/time/time.h"
	#include "content/browser/aggregation_service/aggregation_service_storage.h"
	#include "content/browser/aggregation_service/report_scheduler_timer.h"
	#include "content/common/content_export.h"

	namespace base {
	class ElapsedTimer;
	class Time;
	} // namespace base

	namespace content {

	class AggregatableReportRequest;
	class AggregationServiceStorageContext;

	// UI thread class that is responsible for interacting with the storage layer
	// for report requests, waiting for a report's reporting time to be reached and
	// then calling the appropriate callback.
	//
	// Note that report requests can have one of two states: "pending" or
	// "in-progress". This represents whether the request is currently being
	// processed (i.e. assembled and sent). To ensure that no report is 'lost',
	// all requests (that haven't been deleted) become pending once more on start
	// up. Note that all reports with future report times are pending (unless wall
	// clock time goes backward).
	class CONTENT_EXPORT AggregatableReportScheduler {
	public:
	// Add uniform random noise in the range of [0, 1 minutes] to the report time
	// when the browser comes back online. Aligned with
	// `AttributionStorageDelegateImpl::GetOfflineReportDelayConfig()`.
	static constexpr base::TimeDelta kOfflineReportTimeMinimumDelay =
	base::Minutes(0);
	static constexpr base::TimeDelta kOfflineReportTimeMaximumDelay =
	base::Minutes(1);

	// Configuration for retrying to send reports that failed to send
	static constexpr int kMaxRetries = 2;
	static constexpr base::TimeDelta kInitialRetryDelay = base::Minutes(5);
	static constexpr int kRetryDelayFactor = 3;

	AggregatableReportScheduler(
	AggregationServiceStorageContext* storage_context,
	base::RepeatingCallback<
	void(std::vector<AggregationServiceStorage::RequestAndId>)>
	on_scheduled_report_time_reached);

	AggregatableReportScheduler(const AggregatableReportScheduler& other) =
	delete;
	AggregatableReportScheduler& operator=(
	const AggregatableReportScheduler& other) = delete;
	virtual ~AggregatableReportScheduler();

	// Methods are virtual for testing.

	// Schedules the `request` to be assembled and sent at
	// `request.shared_info().scheduled_report_time`.
	virtual void ScheduleRequest(AggregatableReportRequest request);

	// Notifies that the request to assemble and send the report with `request_id`
	// was successfully completed. There must be an in-progress request stored
	// with that `request_id`.
	virtual void NotifyInProgressRequestSucceeded(
	AggregationServiceStorage::RequestId request_id);

	// Notifies that the request to assemble and send the report with `request_id`
	// completed unsuccessfully. There must be an in-progress request stored with
	// that `request_id`.`failed_attemps_before_sending` is the number of times
	// that this request previously failed. ie. not counting the failure being
	// notified on.
	// Returns true when the request will be scheduled to be retried.
	// Returns false when the request is dropped. ie. it wont be retried.
	virtual bool NotifyInProgressRequestFailed(
	AggregationServiceStorage::RequestId request_id,
	int previous_failed_attempts);

	private:
	class TimerDelegate : public ReportSchedulerTimer::Delegate {
	public:
	TimerDelegate(AggregationServiceStorageContext* storage_context,
	base::RepeatingCallback<void(
	std::vector<AggregationServiceStorage::RequestAndId>)>
	on_scheduled_report_time_reached);
	~TimerDelegate() override;

	TimerDelegate(const TimerDelegate&) = delete;
	TimerDelegate& operator=(const TimerDelegate&) = delete;
	TimerDelegate(TimerDelegate&&) = delete;
	TimerDelegate& operator=(TimerDelegate&&) = delete;

	// Notifies that we no longer need to track `request_id` as in-progress.
	void NotifySendAttemptCompleted(
	AggregationServiceStorage::RequestId request_id);

	base::WeakPtr<AggregatableReportScheduler::TimerDelegate> GetWeakPtr() {
	return weak_ptr_factory_.GetWeakPtr();
	}

	private:
	// ReportSchedulerTimer::Delegate:
	void GetNextReportTime(base::OnceCallback<void(std::optional<base::Time>)>,
	base::Time now) override;
	void OnReportingTimeReached(base::Time now,
	base::Time timer_desired_run_time) override;
	void AdjustOfflineReportTimes(
	base::OnceCallback<void(std::optional<base::Time>)>) override;

	void OnRequestsReturnedFromStorage(
	base::ElapsedTimer task_timer,
	std::vector<AggregationServiceStorage::RequestAndId> requests_and_ids);

	// Using a raw reference is safe because `storage_context_` is guaranteed to
	// outlive `this`.
	raw_ref<AggregationServiceStorageContext> storage_context_;

	// Called when a report request's scheduled report time is reached. May
	// return multiple requests if their report times were all reached before
	// the timer fired. If multiple requests are returned, they will be ordered
	// by the report time (which may differ from the initially scheduled report
	// time).
	base::RepeatingCallback<void(
	std::vector<AggregationServiceStorage::RequestAndId>)>
	on_scheduled_report_time_reached_;

	// The set of IDs of all in-progress report requests.
	// TODO(alexmt): Consider switching to a flat_set when we have metrics on
	// the typical size.
	std::set<AggregationServiceStorage::RequestId> in_progress_requests_;

	// Set iff the private aggregation developer mode is enabled.
	bool should_not_delay_reports_;

	base::WeakPtrFactory<AggregatableReportScheduler::TimerDelegate>
	weak_ptr_factory_{this};
	};

	// Returns how long to wait before attempting to send a report that has
	// previously failed to be sent failed_send_attempts times. Returns
	// `std::nullopt` to indicate that no more attempts should be made.
	// Otherwise, the return value must be positive. `failed_send_attempts`
	// must be positive.
	static std::optional<base::TimeDelta> GetFailedReportDelay(
	int failed_send_attempts);

	// Using a raw reference is safe because `storage_context_` is guaranteed to
	// outlive `this`.
	raw_ref<AggregationServiceStorageContext> storage_context_;

	// Using a raw pointer is safe because it's owned by `timer_`. Will be cleared
	// in the destructor to avoid a dangling pointer.
	raw_ptr<TimerDelegate> timer_delegate_;

	ReportSchedulerTimer timer_;
	};

	} // namespace content

	#endif // CONTENT_BROWSER_AGGREGATION_SERVICE_AGGREGATABLE_REPORT_SCHEDULER_H_