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
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/updater/usage_stats_permissions.h"
#include <algorithm>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
#include "base/apple/foundation_util.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/process/process_iterator.h"
#include "chrome/enterprise_companion/installer_paths.h"
#include "chrome/updater/app/app_utils.h"
#include "chrome/updater/external_constants.h"
#include "chrome/updater/updater_branding.h"
#include "chrome/updater/updater_scope.h"
#include "chrome/updater/util/mac_util.h"
#include "third_party/crashpad/crashpad/client/crash_report_database.h"
#include "third_party/crashpad/crashpad/client/settings.h"
namespace updater {
namespace {
// Returns true if the directory contains a crashpad database with uploads
// enabled.
bool AppAllowsUsageStats(const base::FilePath& app_directory) {
base::FilePath crashpad = app_directory.Append("Crashpad");
if (!base::PathExists(crashpad)) {
return false;
}
std::unique_ptr<crashpad::CrashReportDatabase> app_database =
crashpad::CrashReportDatabase::Initialize(crashpad);
if (!app_database) {
return false;
}
bool enabled = false;
return app_database->GetSettings()->GetUploadsEnabled(&enabled) && enabled;
}
std::vector<base::FilePath> GetAppDirectories(
const std::vector<base::FilePath>& app_support_directories) {
std::vector<base::FilePath> all_apps;
for (const base::FilePath& app_support_directory : app_support_directories) {
base::FileEnumerator(app_support_directory.Append(COMPANY_SHORTNAME_STRING),
/*recursive=*/false,
base::FileEnumerator::FileType::DIRECTORIES)
.ForEach([&all_apps](const base::FilePath& app) {
all_apps.push_back(app);
});
}
return all_apps;
}
} // namespace
// Returns true if any app directory under the associated
// `app_support_directories` has usage stats enabled.
bool AnyAppEnablesUsageStats(
const std::vector<base::FilePath>& app_support_directories) {
return std::ranges::any_of(GetAppDirectories(app_support_directories),
[](const base::FilePath& app_dir) {
return app_dir.BaseName().value() !=
PRODUCT_FULLNAME_STRING &&
AppAllowsUsageStats(app_dir);
});
}
bool RemoteEventLoggingAllowed(
const std::vector<std::string>& installed_app_ids,
const std::vector<base::FilePath>& app_support_directories,
std::optional<EventLoggingPermissionProvider>
event_logging_permission_provider) {
if (!event_logging_permission_provider) {
VLOG(2) << "Event logging disabled by absence of permission provider";
return false;
}
bool manages_additional_apps =
std::ranges::any_of(installed_app_ids, [&](const std::string& app_id) {
return !IsUpdaterOrCompanionApp(app_id) &&
!base::EqualsCaseInsensitiveASCII(
app_id, event_logging_permission_provider->app_id);
});
if (manages_additional_apps) {
VLOG(2) << "Event logging disabled by presence of other apps";
return false;
}
bool allowed = std::ranges::any_of(
app_support_directories,
[&](const base::FilePath& app_support_directory) {
return AppAllowsUsageStats(
app_support_directory.Append(COMPANY_SHORTNAME_STRING)
.Append(event_logging_permission_provider->directory_name));
});
VLOG_IF(2, !allowed) << "Event logging disabled; app "
<< event_logging_permission_provider->app_id
<< " does not enable usage stats";
return allowed;
}
bool AnyAppEnablesUsageStats(UpdaterScope scope) {
return AnyAppEnablesUsageStats(
GetApplicationSupportDirectoriesForScope(scope));
}
bool RemoteEventLoggingAllowed(
UpdaterScope scope,
const std::vector<std::string>& installed_app_ids,
std::optional<EventLoggingPermissionProvider>
event_logging_permission_provider) {
return RemoteEventLoggingAllowed(
installed_app_ids, GetApplicationSupportDirectoriesForScope(scope),
std::move(event_logging_permission_provider));
}
} // namespace updater
|
