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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Copyright 2018 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_ASH_COMPONENT_MANAGER_ASH_H_
#define COMPONENTS_COMPONENT_UPDATER_ASH_COMPONENT_MANAGER_ASH_H_
#include <optional>
#include <string>
#include "base/component_export.h"
#include "base/files/file_path.h"
#include "base/functional/callback_forward.h"
#include "base/memory/ref_counted.h"
#include "base/version.h"
namespace component_updater {
// Contains the path and version of a compatible component.
struct COMPONENT_EXPORT(COMPONENT_UPDATER_ASH) CompatibleComponentInfo {
CompatibleComponentInfo();
CompatibleComponentInfo(const base::FilePath& path_in,
std::optional<base::Version> version_in);
CompatibleComponentInfo(const CompatibleComponentInfo& rhs) = delete;
CompatibleComponentInfo& operator=(const CompatibleComponentInfo& rhs) =
delete;
CompatibleComponentInfo(CompatibleComponentInfo&& rhs);
CompatibleComponentInfo& operator=(CompatibleComponentInfo&& rhs);
~CompatibleComponentInfo();
base::FilePath path;
std::optional<base::Version> version;
};
// This class contains functions used to register and install a component.
//
// This innocuous looking class unfortunately cannot be pure abstract and must
// inherit from base::RefCountedThreadSafe. This class has two concrete
// subclasses: FakeCrOSComponentManager (for tests) and CrOSComponentInstaller
// (for production). The implementation of
// CrOSComponentInstaller::IsRegisteredMayBlock must be called from a thread
// that allows disk IO, whereas all other methods are intended to be called from
// the main thread. There are only two ways to ensure that the base pointer and
// corresponding vtable are still valid from another thread: using a lock or
// ensuring the object is not destroyed. We can't use the former for performance
// reasons -- the entire reason we're dispatching onto another thread is to
// avoid blocking the main thread on disk IO. So the only remaining option is to
// ensure the object stays alive, which we do by using ref-counting. The
// implementation of CrOSComponentInstaller::IsRegisteredMayBlock looks like it
// could be made a static method, but FakeCrOSComponentManager requires a
// non-static method.
//
// This class, with the exception of the method IsRegisteredMayBlock() must only
// be used from the main thread. IsRegisteredMayBlock() must only be used from a
// thread that allows disk IO.
class COMPONENT_EXPORT(COMPONENT_UPDATER_ASH) ComponentManagerAsh
: public base::RefCountedThreadSafe<ComponentManagerAsh> {
public:
ComponentManagerAsh();
// The type of ChromeOS component install result. This enum is tied directly
// to the UMA enum called `ComponentUpdater.InstallResult` defined in
// //tools/metrics/histograms/enums.xml, and should always reflect it (do not
// change one without changing the other). Entries should never be modified or
// reordered. Entries can only be removed by deprecating it and its value
// should never be reused. New ones should be added to the end (right before
// the max value).
enum class Error {
NONE = 0, // No error. Used as a "success code".
UNKNOWN_COMPONENT = 1, // Component requested does not exist.
INSTALL_FAILURE = 2, // update_client fails to install component.
MOUNT_FAILURE = 3, // Component can not be mounted.
COMPATIBILITY_CHECK_FAILED = 4, // Compatibility check failed.
NOT_FOUND = 5, // A component installation was not found - reported for
// load requests with kSkip update policy.
UPDATE_IN_PROGRESS = 6, // Component update in progress.
// Add future entries above this comment, in sync with enums.xml.
// Update kMaxValue to the last value.
kMaxValue = UPDATE_IN_PROGRESS,
};
// Policy on mount operation.
enum class MountPolicy {
// Mount the component if installed.
kMount,
// Skip the mount operation.
kDontMount,
};
// Policy on update operation.
enum class UpdatePolicy {
// Force component update. The component will not be available until the
// Omaha update check is complete.
kForce,
// Do not update if a compatible component is installed. The compatible
// component will load now and any updates will download in the background.
kDontForce,
// Do not run updater, even if a compatible component is not installed at
// the moment.
kSkip
};
// LoadCallback will always return the load result in |error|. If used in
// conjunction with the |kMount| policy below, return the mounted FilePath in
// |path|, or an empty |path| otherwise.
using LoadCallback =
base::OnceCallback<void(Error error, const base::FilePath& path)>;
class Delegate {
public:
virtual ~Delegate() = default;
// Broadcasts a D-Bus signal for a successful component installation.
virtual void EmitInstalledSignal(const std::string& component) = 0;
};
virtual void SetDelegate(Delegate* delegate) = 0;
// Installs a component and keeps it up-to-date.
// The |load_callback| is run on the calling thread.
virtual void Load(const std::string& name,
MountPolicy mount_policy,
UpdatePolicy update_policy,
LoadCallback load_callback) = 0;
// Stops updating and removes a component.
// Returns true if the component was successfully unloaded
// or false if it couldn't be unloaded or already wasn't loaded.
virtual bool Unload(const std::string& name) = 0;
// Gets version of a component. `version_callback` runs on the calling thread.
// Return invalid base::Version() as `version` if the error occurs.
virtual void GetVersion(const std::string& name,
base::OnceCallback<void(const base::Version& version)>
version_callback) const = 0;
// Saves the information related to a compatible component.
virtual void RegisterCompatiblePath(const std::string& name,
CompatibleComponentInfo info) = 0;
// Removes the name and install path entry of a component.
virtual void UnregisterCompatiblePath(const std::string& name) = 0;
// Returns installed path of a compatible component given |name|. Returns an
// empty path if the component isn't compatible.
virtual base::FilePath GetCompatiblePath(const std::string& name) const = 0;
// Returns true if any previously registered version of a component exists,
// even if it is incompatible.
// This method must only be called on a thread that allows disk IO.
virtual bool IsRegisteredMayBlock(const std::string& name) = 0;
// Register all installed components.
virtual void RegisterInstalled() = 0;
protected:
virtual ~ComponentManagerAsh();
private:
friend class base::RefCountedThreadSafe<ComponentManagerAsh>;
};
} // namespace component_updater
#endif // COMPONENTS_COMPONENT_UPDATER_ASH_COMPONENT_MANAGER_ASH_H_
|
