1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// Copyright 2015 The Chromium Authors
// 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 <optional>
#include <string>
#include <vector>
#include "base/containers/flat_map.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/sequence_checker.h"
#include "components/component_updater/update_scheduler.h"
#include "components/update_client/persisted_data.h"
namespace base {
class TimeTicks;
}
namespace update_client {
enum class Error;
}
namespace component_updater {
class OnDemandUpdater;
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<update_client::UpdateClient> update_client,
const std::string& brand);
CrxUpdateService(const CrxUpdateService&) = delete;
CrxUpdateService& operator=(const CrxUpdateService&) = delete;
~CrxUpdateService() override;
// Overrides for ComponentUpdateService.
void AddObserver(Observer* observer) override;
void RemoveObserver(Observer* observer) override;
bool RegisterComponent(const ComponentRegistration& component) override;
bool UnregisterComponent(const std::string& id) override;
std::vector<std::string> GetComponentIDs() 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;
base::Version GetRegisteredVersion(const std::string& app_id) override;
base::Version GetMaxPreviousProductVersion(
const std::string& app_id) override;
// Overrides for Observer.
void OnEvent(const CrxUpdateItem& item) 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 std::string& id);
CrxComponent ToCrxComponent(const ComponentRegistration& component) const;
std::optional<ComponentRegistration> GetComponent(
const std::string& id) const;
const CrxUpdateItem* GetComponentState(const std::string& id) const;
void GetCrxComponents(
const std::vector<std::string>& ids,
base::OnceCallback<void(const std::vector<std::optional<CrxComponent>>&)>
callback);
void OnUpdateComplete(Callback callback,
const base::TimeTicks& start_time,
update_client::Error error);
SEQUENCE_CHECKER(sequence_checker_);
scoped_refptr<Configurator> config_;
std::unique_ptr<UpdateScheduler> scheduler_;
scoped_refptr<update_client::UpdateClient> update_client_;
std::string brand_;
// A collection of every registered component.
using Components = base::flat_map<std::string, ComponentRegistration>;
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_;
base::WeakPtrFactory<CrxUpdateService> weak_ptr_factory_{this};
};
} // namespace component_updater
#endif // COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_INTERNAL_H_
|
