// Copyright 2015 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_DOMAIN_RELIABILITY_CONTEXT_MANAGER_H_ #define COMPONENTS_DOMAIN_RELIABILITY_CONTEXT_MANAGER_H_ #include #include #include #include #include "base/memory/raw_ptr.h" #include "base/time/time.h" #include "base/values.h" #include "components/domain_reliability/beacon.h" #include "components/domain_reliability/config.h" #include "components/domain_reliability/context.h" #include "components/domain_reliability/domain_reliability_export.h" #include "url/gurl.h" namespace domain_reliability { // Owns DomainReliabilityContexts, receives Beacons and queues them in the // appropriate Context. // TODO(chlily): This class should be merged with the DomainReliabilityMonitor. class DOMAIN_RELIABILITY_EXPORT DomainReliabilityContextManager { public: DomainReliabilityContextManager( const MockableTime* time, const std::string& upload_reporter_string, DomainReliabilityContext::UploadAllowedCallback upload_allowed_callback, DomainReliabilityDispatcher* dispatcher); DomainReliabilityContextManager(const DomainReliabilityContextManager&) = delete; DomainReliabilityContextManager& operator=( const DomainReliabilityContextManager&) = delete; ~DomainReliabilityContextManager(); // If |url| maps to a context added to this manager, calls |OnBeacon| on // that context with |beacon|. Otherwise, does nothing. // Prefers contexts that are an exact match for the beacon's url's hostname // over a subdomain-inclusive context for the beacon's superdomain. // If the beacon should be routed to a Google config that has not yet been // created, this will create it first. void RouteBeacon(std::unique_ptr beacon); // Calls |ClearBeacons| on all contexts matched by |origin_filter| added // to this manager, but leaves the contexts themselves intact. A null // |origin_filter| is interpreted as an always-true filter, indicating // complete deletion. void ClearBeacons( const base::RepeatingCallback& origin_filter); // Creates and stores a context for the given |config|, which should be for an // origin distinct from any existing ones. Returns pointer to the inserted // context. DomainReliabilityContext* AddContextForConfig( std::unique_ptr config); // Removes all contexts matched by |origin_filter| from this manager // (discarding all queued beacons in the process). A null |origin_filter| // is interpreted as an always-true filter, indicating complete deletion. void RemoveContexts( const base::RepeatingCallback& origin_filter); // Finds a context for the exact domain |host|. Otherwise returns nullptr. DomainReliabilityContext* GetContext(const std::string& host) const; // Finds a context for the parent domain of |host|, which must include // subdomains. Otherwise returns nullptr. DomainReliabilityContext* GetSuperdomainContext( const std::string& host) const; void OnNetworkChanged(base::TimeTicks now); // Called by the Monitor during initialization. Should be called exactly once. // |uploader_| needs to be set before any contexts are created. void SetUploader(DomainReliabilityUploader* uploader); size_t contexts_size_for_testing() const { return contexts_.size(); } private: // Maps the hostname to the DomainReliabilityContext for that origin. using ContextMap = std::map>; std::unique_ptr CreateContextForConfig( std::unique_ptr config) const; // |time_| is owned by the Monitor and a copy of this pointer is given to // every Context. const raw_ptr time_; const std::string upload_reporter_string_; base::TimeTicks last_network_change_time_; DomainReliabilityContext::UploadAllowedCallback upload_allowed_callback_; // |dispatcher_| is owned by the Monitor and a copy of this pointer is given // to every Context. const raw_ptr dispatcher_; // |uploader_| is owned by the Monitor. Expected to be non-null after // initialization because it should be set by the Monitor, as long as the // Monitor has been fully initialized. A copy of this pointer is given to // every Context. raw_ptr uploader_ = nullptr; ContextMap contexts_; }; } // namespace domain_reliability #endif // COMPONENTS_DOMAIN_RELIABILITY_CONTEXT_MANAGER_H_