forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
component_updater_service_internal.h
133 lines (101 loc) · 4.75 KB
/
component_updater_service_internal.h
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
// 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_