| // Copyright 2020 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef COMPONENTS_PERMISSIONS_PERMISSION_AUDITING_SERVICE_H_ |
| #define COMPONENTS_PERMISSIONS_PERMISSION_AUDITING_SERVICE_H_ |
| |
| #include "base/callback_forward.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/task/sequenced_task_runner.h" |
| #include "base/timer/timer.h" |
| #include "components/content_settings/core/common/content_settings_types.h" |
| #include "components/keyed_service/core/keyed_service.h" |
| #include "url/origin.h" |
| |
| namespace base { |
| class FilePath; |
| class Time; |
| class TimeDelta; |
| } // namespace base |
| |
| namespace permissions { |
| |
| class PermissionAuditingDatabase; |
| struct PermissionUsageSession; |
| |
| // Keeps a client-side log of when websites use permission-gated capabilities to |
| // allow the user to audit usage. |
| // |
| // For each combination of permission type and origin, the history is |
| // stored on disk as a series of PermissionUsageSessions. Sessions expire |
| // at the latest after 3 months, or when browsing data or history is cleared. |
| class PermissionAuditingService |
| : public KeyedService, |
| public base::SupportsWeakPtr<PermissionAuditingService> { |
| public: |
| typedef base::OnceCallback<void(std::vector<PermissionUsageSession>)> |
| PermissionUsageHistoryCallback; |
| |
| typedef base::OnceCallback<void(absl::optional<base::Time>)> |
| LastPermissionUsageTimeCallback; |
| |
| explicit PermissionAuditingService( |
| scoped_refptr<base::SequencedTaskRunner> backend_task_runner); |
| |
| ~PermissionAuditingService() override; |
| |
| // Initializes Permission Auditing database in `database_path`. |
| void Init(const base::FilePath& database_path); |
| |
| // Starts the periodic deletions of outdated sessions. |
| void StartPeriodicCullingOfExpiredSessions(); |
| |
| // Appends a new permission usage `session` of the given permission `type` on |
| // a given `origin`. `session` must be valid according to IsValid(). |
| // Operation will fail if a session with the same primary key, that is, |
| // origin, type, and usage start time, already exists. |
| void StorePermissionUsage(const PermissionUsageSession& session); |
| |
| // Returns the detailed history stored for the permission `type` on a given |
| // `origin` from the specified `start_time` inclusive. The `origin` must not |
| // be opaque. History is provided via `result_callback`. History isn't ordered |
| // in any way. |
| void GetPermissionUsageHistory( |
| ContentSettingsType type, |
| const url::Origin& origin, |
| base::Time start_time, |
| PermissionUsageHistoryCallback result_callback); |
| |
| // Returns when the given permission `type` was last used on a given `origin`. |
| // The `origin` must not be opaque. Time is provided via `result_callback`. |
| void GetLastPermissionUsageTime( |
| ContentSettingsType type, |
| const url::Origin& origin, |
| LastPermissionUsageTimeCallback result_callback); |
| |
| // Updates the usage end time for a specific usage session. The session is |
| // identified by the primary key {`type`, `origin`, `start_time`}, and must |
| // already exist. `start_time` and `new_end_time` must be not null, and |
| // `start_time` must be less than or equal to `new_end_time`. |
| void UpdateEndTime(ContentSettingsType type, |
| const url::Origin& origin, |
| base::Time start_time, |
| base::Time new_end_time); |
| |
| // Deletes permission usage sessions, which started or ended in the given |
| // time range inclusive. A null `start_time` or `end_time` time is treated as |
| // -inf and +inf, respectively. |
| void DeleteSessionsBetween(base::Time start, base::Time end); |
| |
| // Returns sessions maximum lifetime. |
| static base::TimeDelta GetUsageSessionMaxAge(); |
| |
| // Returns the time delta between two consequent expiration iterations. |
| static base::TimeDelta GetUsageSessionCullingInterval(); |
| |
| private: |
| void ExpireOldSessions(); |
| |
| scoped_refptr<base::SequencedTaskRunner> backend_task_runner_; |
| |
| // Lives on the |backend_task_runner_|, and must only be accessed on that |
| // sequence. It is safe to assume the database is alive as long as |db_| is |
| // non-null. |
| raw_ptr<PermissionAuditingDatabase> db_ = nullptr; |
| |
| base::RepeatingTimer timer_; |
| }; |
| |
| } // namespace permissions |
| |
| #endif // COMPONENTS_PERMISSIONS_PERMISSION_AUDITING_SERVICE_H_ |