| // 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_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_INTERNAL_H_ |
| #define COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_INTERNAL_H_ |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/optional.h" |
| #include "base/threading/thread_checker.h" |
| #include "components/component_updater/update_scheduler.h" |
| |
| namespace base { |
| class TimeTicks; |
| } |
| |
| namespace update_client { |
| enum class Error; |
| } |
| |
| namespace component_updater { |
| |
| class OnDemandUpdater; |
| |
| using CrxInstaller = update_client::CrxInstaller; |
| using UpdateClient = update_client::UpdateClient; |
| |
| class CrxUpdateService : public ComponentUpdateService, |
| public ComponentUpdateService::Observer, |
| public OnDemandUpdater { |
| using Observer = ComponentUpdateService::Observer; |
| |
| public: |
| CrxUpdateService(scoped_refptr<Configurator> config, |
| std::unique_ptr<UpdateScheduler> scheduler, |
| scoped_refptr<UpdateClient> update_client); |
| ~CrxUpdateService() override; |
| |
| // Overrides for ComponentUpdateService. |
| void AddObserver(Observer* observer) override; |
| void RemoveObserver(Observer* observer) override; |
| bool RegisterComponent(const CrxComponent& component) override; |
| bool UnregisterComponent(const std::string& id) override; |
| std::vector<std::string> GetComponentIDs() const override; |
| std::unique_ptr<ComponentInfo> GetComponentForMimeType( |
| const std::string& id) const override; |
| std::vector<ComponentInfo> GetComponents() const override; |
| OnDemandUpdater& GetOnDemandUpdater() override; |
| void MaybeThrottle(const std::string& id, |
| base::OnceClosure callback) override; |
| bool GetComponentDetails(const std::string& id, |
| CrxUpdateItem* item) const override; |
| |
| // Overrides for Observer. |
| void OnEvent(Events event, const std::string& id) override; |
| |
| // Overrides for OnDemandUpdater. |
| void OnDemandUpdate(const std::string& id, |
| Priority priority, |
| Callback callback) override; |
| |
| private: |
| void Start(); |
| void Stop(); |
| |
| bool CheckForUpdates(UpdateScheduler::OnFinishedCallback on_finished); |
| |
| void OnDemandUpdateInternal(const std::string& id, |
| Priority priority, |
| Callback callback); |
| bool OnDemandUpdateWithCooldown(const std::string& id); |
| |
| bool DoUnregisterComponent(const CrxComponent& component); |
| |
| base::Optional<CrxComponent> GetComponent(const std::string& id) const; |
| |
| const CrxUpdateItem* GetComponentState(const std::string& id) const; |
| |
| std::vector<base::Optional<CrxComponent>> GetCrxComponents( |
| const std::vector<std::string>& ids); |
| void OnUpdateComplete(Callback callback, |
| const base::TimeTicks& start_time, |
| update_client::Error error); |
| |
| base::ThreadChecker thread_checker_; |
| |
| scoped_refptr<Configurator> config_; |
| std::unique_ptr<UpdateScheduler> scheduler_; |
| |
| scoped_refptr<UpdateClient> update_client_; |
| |
| // A collection of every registered component. |
| using Components = std::map<std::string, CrxComponent>; |
| Components components_; |
| |
| // Maintains the order in which components have been registered. The position |
| // of a component id in this sequence indicates the priority of the component. |
| // The sooner the component gets registered, the higher its priority, and |
| // the closer this component is to the beginning of the vector. |
| std::vector<std::string> components_order_; |
| |
| // Contains the components pending unregistration. If a component is not |
| // busy installing or updating, it can be unregistered right away. Otherwise, |
| // the component will be lazily unregistered after the its operations have |
| // completed. |
| std::vector<std::string> components_pending_unregistration_; |
| |
| // Contains the active resource throttles associated with a given component. |
| using ResourceThrottleCallbacks = |
| std::multimap<std::string, base::OnceClosure>; |
| ResourceThrottleCallbacks ready_callbacks_; |
| |
| // Contains the state of the component. |
| using ComponentStates = std::map<std::string, CrxUpdateItem>; |
| ComponentStates component_states_; |
| |
| // Contains a map of media types to the component that implements a handler |
| // for that media type. Only the most recently-registered component is |
| // tracked. May include the IDs of un-registered components. |
| std::map<std::string, std::string> component_ids_by_mime_type_; |
| |
| DISALLOW_COPY_AND_ASSIGN(CrxUpdateService); |
| }; |
| |
| } // namespace component_updater |
| |
| #endif // COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_INTERNAL_H_ |