1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/metrics/chrome_metrics_service_client.h"
6
7 #include <stddef.h>
8
9 #include <memory>
10 #include <set>
11 #include <utility>
12 #include <vector>
13
14 #include "base/base64.h"
15 #include "base/bind.h"
16 #include "base/callback.h"
17 #include "base/check_op.h"
18 #include "base/command_line.h"
19 #include "base/files/file_path.h"
20 #include "base/files/file_util.h"
21 #include "base/lazy_instance.h"
22 #include "base/metrics/field_trial_params.h"
23 #include "base/metrics/histogram_macros.h"
24 #include "base/metrics/persistent_histogram_allocator.h"
25 #include "base/metrics/persistent_memory_allocator.h"
26 #include "base/metrics/statistics_recorder.h"
27 #include "base/notreached.h"
28 #include "base/path_service.h"
29 #include "base/rand_util.h"
30 #include "base/stl_util.h"
31 #include "base/strings/string16.h"
32 #include "base/strings/string_piece.h"
33 #include "base/task/task_traits.h"
34 #include "base/task/thread_pool.h"
35 #include "base/threading/platform_thread.h"
36 #include "base/threading/sequenced_task_runner_handle.h"
37 #include "base/threading/thread_task_runner_handle.h"
38 #include "build/build_config.h"
39 #include "build/chromeos_buildflags.h"
40 #include "chrome/browser/browser_process.h"
41 #include "chrome/browser/chrome_notification_types.h"
42 #include "chrome/browser/google/google_brand.h"
43 #include "chrome/browser/history/history_service_factory.h"
44 #include "chrome/browser/metrics/cached_metrics_profile.h"
45 #include "chrome/browser/metrics/chrome_metrics_extensions_helper.h"
46 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
47 #include "chrome/browser/metrics/desktop_platform_features_metrics_provider.h"
48 #include "chrome/browser/metrics/desktop_session_duration/desktop_profile_session_durations_service_factory.h"
49 #include "chrome/browser/metrics/https_engagement_metrics_provider.h"
50 #include "chrome/browser/metrics/metrics_reporting_state.h"
51 #include "chrome/browser/metrics/network_quality_estimator_provider_impl.h"
52 #include "chrome/browser/metrics/sampling_metrics_provider.h"
53 #include "chrome/browser/privacy_budget/privacy_budget_prefs.h"
54 #include "chrome/browser/privacy_budget/privacy_budget_ukm_entry_filter.h"
55 #include "chrome/browser/profiles/profile_manager.h"
56 #include "chrome/browser/safe_browsing/certificate_reporting_metrics_provider.h"
57 #include "chrome/browser/sync/device_info_sync_service_factory.h"
58 #include "chrome/browser/sync/profile_sync_service_factory.h"
59 #include "chrome/browser/tracing/background_tracing_metrics_provider.h"
60 #include "chrome/browser/translate/translate_ranker_metrics_provider.h"
61 #include "chrome/common/buildflags.h"
62 #include "chrome/common/channel_info.h"
63 #include "chrome/common/chrome_features.h"
64 #include "chrome/common/chrome_paths.h"
65 #include "chrome/common/chrome_paths_internal.h"
66 #include "chrome/common/chrome_switches.h"
67 #include "chrome/common/pref_names.h"
68 #include "components/crash/core/common/crash_keys.h"
69 #include "components/history/core/browser/history_service.h"
70 #include "components/metrics/call_stack_profile_metrics_provider.h"
71 #include "components/metrics/component_metrics_provider.h"
72 #include "components/metrics/content/content_stability_metrics_provider.h"
73 #include "components/metrics/content/gpu_metrics_provider.h"
74 #include "components/metrics/content/rendering_perf_metrics_provider.h"
75 #include "components/metrics/content/subprocess_metrics_provider.h"
76 #include "components/metrics/cpu_metrics_provider.h"
77 #include "components/metrics/demographics/demographic_metrics_provider.h"
78 #include "components/metrics/drive_metrics_provider.h"
79 #include "components/metrics/entropy_state_provider.h"
80 #include "components/metrics/metrics_log_uploader.h"
81 #include "components/metrics/metrics_pref_names.h"
82 #include "components/metrics/metrics_reporting_default_state.h"
83 #include "components/metrics/metrics_service.h"
84 #include "components/metrics/metrics_service_client.h"
85 #include "components/metrics/metrics_state_manager.h"
86 #include "components/metrics/metrics_switches.h"
87 #include "components/metrics/net/cellular_logic_helper.h"
88 #include "components/metrics/net/net_metrics_log_uploader.h"
89 #include "components/metrics/net/network_metrics_provider.h"
90 #include "components/metrics/persistent_histograms.h"
91 #include "components/metrics/stability_metrics_helper.h"
92 #include "components/metrics/ui/screen_info_metrics_provider.h"
93 #include "components/metrics/url_constants.h"
94 #include "components/metrics/version_utils.h"
95 #include "components/network_time/network_time_tracker.h"
96 #include "components/omnibox/browser/omnibox_metrics_provider.h"
97 #include "components/prefs/pref_registry_simple.h"
98 #include "components/prefs/pref_service.h"
99 #include "components/sync/driver/passphrase_type_metrics_provider.h"
100 #include "components/sync/driver/sync_service.h"
101 #include "components/sync_device_info/device_count_metrics_provider.h"
102 #include "components/ukm/field_trials_provider_helper.h"
103 #include "components/ukm/ukm_service.h"
104 #include "components/version_info/version_info.h"
105 #include "content/public/browser/browser_task_traits.h"
106 #include "content/public/browser/browser_thread.h"
107 #include "content/public/browser/histogram_fetcher.h"
108 #include "content/public/browser/network_service_instance.h"
109 #include "content/public/browser/notification_service.h"
110 #include "google_apis/google_api_keys.h"
111 #include "ppapi/buildflags/buildflags.h"
112 #include "printing/buildflags/buildflags.h"
113 #include "services/network/public/cpp/shared_url_loader_factory.h"
114
115 #if defined(OS_ANDROID)
116 #include "chrome/browser/metrics/chrome_android_metrics_provider.h"
117 #include "chrome/browser/metrics/page_load_metrics_provider.h"
118 #include "components/metrics/android_metrics_provider.h"
119 #else
120 #include "chrome/browser/metrics/browser_activity_watcher.h"
121 #endif
122
123 #if defined(OS_POSIX)
124 #include <signal.h>
125 #endif
126
127 #if BUILDFLAG(ENABLE_PRINT_PREVIEW) && !defined(OS_CHROMEOS)
128 #include "chrome/browser/service_process/service_process_control.h"
129 #endif
130
131 #if BUILDFLAG(ENABLE_EXTENSIONS)
132 #include "chrome/browser/metrics/extensions_metrics_provider.h"
133 #include "extensions/browser/extension_registry.h"
134 #include "extensions/buildflags/buildflags.h"
135 #include "extensions/common/extension.h"
136 #endif
137
138 #if BUILDFLAG(ENABLE_PLUGINS)
139 #include "chrome/browser/metrics/plugin_metrics_provider.h"
140 #endif
141
142 #if BUILDFLAG(IS_LACROS)
143 #include "chrome/browser/metrics/lacros_metrics_provider.h"
144 #endif
145
146 #if defined(OS_CHROMEOS)
147 #include "base/feature_list.h"
148 #include "chrome/browser/chromeos/child_accounts/family_features.h"
149 #include "chrome/browser/chromeos/printing/printer_metrics_provider.h"
150 #include "chrome/browser/chromeos/profiles/profile_helper.h"
151 #include "chrome/browser/metrics/ambient_mode_metrics_provider.h"
152 #include "chrome/browser/metrics/assistant_service_metrics_provider.h"
153 #include "chrome/browser/metrics/chromeos_metrics_provider.h"
154 #include "chrome/browser/metrics/cros_healthd_metrics_provider.h"
155 #include "chrome/browser/metrics/family_link_user_metrics_provider.h"
156 #include "chrome/browser/metrics/family_user_metrics_provider.h"
157 #include "chrome/browser/signin/signin_status_metrics_provider_chromeos.h"
158 #include "components/metrics/structured/structured_metrics_provider.h"
159 #endif // defined(OS_CHROMEOS)
160
161 #if defined(OS_WIN)
162 #include <windows.h>
163
164 #include "chrome/browser/metrics/antivirus_metrics_provider_win.h"
165 #include "chrome/browser/metrics/google_update_metrics_provider_win.h"
166 #include "chrome/install_static/install_util.h"
167 #include "chrome/installer/util/util_constants.h"
168 #include "chrome/notification_helper/notification_helper_constants.h"
169 #include "content/public/browser/system_connector.h"
170 #endif
171
172 #if defined(OS_WIN) || defined(OS_MAC) || defined(OS_ANDROID)
173 #include "third_party/crashpad/crashpad/client/crashpad_info.h"
174 #endif
175
176 #if !defined(OS_CHROMEOS)
177 #include "chrome/browser/metrics/accessibility_metrics_provider.h"
178 #include "chrome/browser/signin/chrome_signin_status_metrics_provider_delegate.h"
179 #include "components/signin/core/browser/signin_status_metrics_provider.h"
180 #endif // !defined(OS_CHROMEOS)
181
182 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
183 #include "chrome/browser/metrics/upgrade_metrics_provider.h"
184 #endif // !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
185
186 #if defined(OS_MAC)
187 #include "chrome/browser/metrics/power_metrics_provider_mac.h"
188 #endif
189
190 namespace {
191
192 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
193 const int kMaxHistogramStorageKiB = 100 << 10; // 100 MiB
194 #else
195 const int kMaxHistogramStorageKiB = 500 << 10; // 500 MiB
196 #endif
197
198 // This specifies the amount of time to wait for all renderers to send their
199 // data.
200 const int kMaxHistogramGatheringWaitDuration = 60000; // 60 seconds.
201
202 // Needs to be kept in sync with the writer in
203 // third_party/crashpad/crashpad/handler/handler_main.cc.
204 const char kCrashpadHistogramAllocatorName[] = "CrashpadMetrics";
205
206 #if defined(OS_WIN) || defined(OS_MAC) || defined(OS_ANDROID)
207 // The stream type assigned to the minidump stream that holds the serialized
208 // system profile proto.
209 const uint32_t kSystemProfileMinidumpStreamType = 0x4B6B0003;
210
211 // A serialized environment (SystemProfileProto) that was registered with the
212 // crash reporter, or the empty string if no environment was registered yet.
213 // Ownership must be maintained after registration as the crash reporter does
214 // not assume it.
215 // TODO(manzagop): revisit this if the Crashpad API evolves.
216 base::LazyInstance<std::string>::Leaky g_environment_for_crash_reporter;
217 #endif // defined(OS_WIN) || defined(OS_MAC) || defined(OS_ANDROID)
218
RegisterFileMetricsPreferences(PrefRegistrySimple * registry)219 void RegisterFileMetricsPreferences(PrefRegistrySimple* registry) {
220 metrics::FileMetricsProvider::RegisterSourcePrefs(registry,
221 kBrowserMetricsName);
222
223 metrics::FileMetricsProvider::RegisterSourcePrefs(
224 registry, kCrashpadHistogramAllocatorName);
225
226 #if defined(OS_WIN)
227 metrics::FileMetricsProvider::RegisterSourcePrefs(
228 registry, installer::kSetupHistogramAllocatorName);
229
230 metrics::FileMetricsProvider::RegisterSourcePrefs(
231 registry, notification_helper::kNotificationHelperHistogramAllocatorName);
232 #endif
233 }
234
235 // Constructs the name of a persistent metrics file from a directory and metrics
236 // name, and either registers that file as associated with a previous run if
237 // metrics reporting is enabled, or deletes it if not.
RegisterOrRemovePreviousRunMetricsFile(bool metrics_reporting_enabled,const base::FilePath & dir,base::StringPiece metrics_name,metrics::FileMetricsProvider::SourceAssociation association,metrics::FileMetricsProvider * file_metrics_provider)238 void RegisterOrRemovePreviousRunMetricsFile(
239 bool metrics_reporting_enabled,
240 const base::FilePath& dir,
241 base::StringPiece metrics_name,
242 metrics::FileMetricsProvider::SourceAssociation association,
243 metrics::FileMetricsProvider* file_metrics_provider) {
244 base::FilePath metrics_file;
245 base::GlobalHistogramAllocator::ConstructFilePaths(
246 dir, metrics_name, &metrics_file, nullptr, nullptr);
247
248 if (metrics_reporting_enabled) {
249 // Enable reading any existing saved metrics.
250 file_metrics_provider->RegisterSource(metrics::FileMetricsProvider::Params(
251 metrics_file,
252 metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
253 association, metrics_name));
254 } else {
255 // When metrics reporting is not enabled, any existing file should be
256 // deleted in order to preserve user privacy.
257 base::ThreadPool::PostTask(
258 FROM_HERE,
259 {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
260 base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
261 base::BindOnce(base::GetDeleteFileCallback(), metrics_file));
262 }
263 }
264
CreateFileMetricsProvider(bool metrics_reporting_enabled)265 std::unique_ptr<metrics::FileMetricsProvider> CreateFileMetricsProvider(
266 bool metrics_reporting_enabled) {
267 // Create an object to monitor files of metrics and include them in reports.
268 std::unique_ptr<metrics::FileMetricsProvider> file_metrics_provider(
269 new metrics::FileMetricsProvider(g_browser_process->local_state()));
270
271 base::FilePath user_data_dir;
272 if (base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
273 // Register the Crashpad metrics files.
274 // Register the data from the previous run if crashpad_handler didn't exit
275 // cleanly.
276 RegisterOrRemovePreviousRunMetricsFile(
277 metrics_reporting_enabled, user_data_dir,
278 kCrashpadHistogramAllocatorName,
279 metrics::FileMetricsProvider::
280 ASSOCIATE_INTERNAL_PROFILE_OR_PREVIOUS_RUN,
281 file_metrics_provider.get());
282
283 base::FilePath browser_metrics_upload_dir =
284 user_data_dir.AppendASCII(kBrowserMetricsName);
285 if (metrics_reporting_enabled) {
286 metrics::FileMetricsProvider::Params browser_metrics_params(
287 browser_metrics_upload_dir,
288 metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_DIR,
289 metrics::FileMetricsProvider::ASSOCIATE_INTERNAL_PROFILE,
290 kBrowserMetricsName);
291 browser_metrics_params.max_dir_kib = kMaxHistogramStorageKiB;
292 browser_metrics_params.filter = base::BindRepeating(
293 &ChromeMetricsServiceClient::FilterBrowserMetricsFiles);
294 file_metrics_provider->RegisterSource(browser_metrics_params);
295
296 base::FilePath active_path;
297 base::GlobalHistogramAllocator::ConstructFilePaths(
298 user_data_dir, kCrashpadHistogramAllocatorName, nullptr, &active_path,
299 nullptr);
300 // Register data that will be populated for the current run. "Active"
301 // files need an empty "prefs_key" because they update the file itself.
302 file_metrics_provider->RegisterSource(
303 metrics::FileMetricsProvider::Params(
304 active_path,
305 metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ACTIVE_FILE,
306 metrics::FileMetricsProvider::ASSOCIATE_CURRENT_RUN));
307 } else {
308 // When metrics reporting is not enabled, any existing files should be
309 // deleted in order to preserve user privacy.
310 base::ThreadPool::PostTask(
311 FROM_HERE,
312 {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
313 base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
314 base::BindOnce(base::GetDeletePathRecursivelyCallback(),
315 std::move(browser_metrics_upload_dir)));
316 }
317 }
318
319 #if defined(OS_WIN)
320 // Read metrics file from setup.exe.
321 base::FilePath program_dir;
322 base::PathService::Get(base::DIR_EXE, &program_dir);
323 file_metrics_provider->RegisterSource(metrics::FileMetricsProvider::Params(
324 program_dir.AppendASCII(installer::kSetupHistogramAllocatorName),
325 metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_DIR,
326 metrics::FileMetricsProvider::ASSOCIATE_CURRENT_RUN,
327 installer::kSetupHistogramAllocatorName));
328
329 // When metrics reporting is enabled, register the notification_helper metrics
330 // files; otherwise delete any existing files in order to preserve user
331 // privacy.
332 if (!user_data_dir.empty()) {
333 base::FilePath notification_helper_metrics_upload_dir =
334 user_data_dir.AppendASCII(
335 notification_helper::kNotificationHelperHistogramAllocatorName);
336
337 if (metrics_reporting_enabled) {
338 file_metrics_provider->RegisterSource(
339 metrics::FileMetricsProvider::Params(
340 notification_helper_metrics_upload_dir,
341 metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_DIR,
342 metrics::FileMetricsProvider::ASSOCIATE_CURRENT_RUN,
343 notification_helper::kNotificationHelperHistogramAllocatorName));
344 } else {
345 base::ThreadPool::PostTask(
346 FROM_HERE,
347 {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
348 base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
349 base::BindOnce(base::GetDeletePathRecursivelyCallback(),
350 std::move(notification_helper_metrics_upload_dir)));
351 }
352 }
353 #endif
354
355 return file_metrics_provider;
356 }
357
358 ChromeMetricsServiceClient::IsProcessRunningFunction g_is_process_running =
359 nullptr;
360
IsProcessRunning(base::ProcessId pid)361 bool IsProcessRunning(base::ProcessId pid) {
362 // Use any "override" method if one is set (for testing).
363 if (g_is_process_running)
364 return g_is_process_running(pid);
365
366 #if defined(OS_WIN)
367 HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid);
368 if (process) {
369 DWORD ret = WaitForSingleObject(process, 0);
370 CloseHandle(process);
371 if (ret == WAIT_TIMEOUT)
372 return true;
373 }
374 #elif defined(OS_POSIX)
375 // Sending a signal value of 0 will cause error checking to be performed
376 // with no signal being sent.
377 if (kill(pid, 0) == 0 || errno != ESRCH)
378 return true;
379 #else
380 #error Unsupported OS. Might be okay to just return false.
381 #endif
382
383 return false;
384 }
385
386 // Client used by DemographicMetricsProvider to retrieve Profile information.
387 class ProfileClientImpl
388 : public metrics::DemographicMetricsProvider::ProfileClient {
389 public:
~ProfileClientImpl()390 ~ProfileClientImpl() override {}
391 ProfileClientImpl() = default;
392
GetNumberOfProfilesOnDisk()393 int GetNumberOfProfilesOnDisk() override {
394 return g_browser_process->profile_manager()->GetNumberOfProfiles();
395 }
396
GetPrefService()397 PrefService* GetPrefService() override {
398 Profile* profile = cached_metrics_profile_.GetMetricsProfile();
399 if (!profile)
400 return nullptr;
401
402 return profile->GetPrefs();
403 }
404
GetSyncService()405 syncer::SyncService* GetSyncService() override {
406 Profile* profile = cached_metrics_profile_.GetMetricsProfile();
407 if (!profile)
408 return nullptr;
409
410 return ProfileSyncServiceFactory::GetForProfile(profile);
411 }
412
GetNetworkTime() const413 base::Time GetNetworkTime() const override {
414 base::Time time;
415 if (g_browser_process->network_time_tracker()->GetNetworkTime(&time,
416 nullptr) !=
417 network_time::NetworkTimeTracker::NETWORK_TIME_AVAILABLE) {
418 // Return null time to indicate that it could not get the network time. It
419 // is the responsibility of the client to have the strategy to deal with
420 // the absence of network time.
421 return base::Time();
422 }
423 return time;
424 }
425
426 private:
427 // Provides the same cached Profile each time.
428 metrics::CachedMetricsProfile cached_metrics_profile_;
429
430 DISALLOW_COPY_AND_ASSIGN(ProfileClientImpl);
431 };
432
433 std::unique_ptr<metrics::DemographicMetricsProvider>
MakeDemographicMetricsProvider(metrics::MetricsLogUploader::MetricServiceType metrics_service_type)434 MakeDemographicMetricsProvider(
435 metrics::MetricsLogUploader::MetricServiceType metrics_service_type) {
436 return std::make_unique<metrics::DemographicMetricsProvider>(
437 std::make_unique<ProfileClientImpl>(), metrics_service_type);
438 }
439
440 } // namespace
441
ChromeMetricsServiceClient(metrics::MetricsStateManager * state_manager)442 ChromeMetricsServiceClient::ChromeMetricsServiceClient(
443 metrics::MetricsStateManager* state_manager)
444 : metrics_state_manager_(state_manager) {
445 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
446 RecordCommandLineMetrics();
447 incognito_observer_ = IncognitoObserver::Create(
448 base::BindRepeating(&ChromeMetricsServiceClient::UpdateRunningServices,
449 weak_ptr_factory_.GetWeakPtr()));
450 }
451
~ChromeMetricsServiceClient()452 ChromeMetricsServiceClient::~ChromeMetricsServiceClient() {
453 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
454 }
455
456 // static
Create(metrics::MetricsStateManager * state_manager)457 std::unique_ptr<ChromeMetricsServiceClient> ChromeMetricsServiceClient::Create(
458 metrics::MetricsStateManager* state_manager) {
459 // Perform two-phase initialization so that |client->metrics_service_| only
460 // receives pointers to fully constructed objects.
461 std::unique_ptr<ChromeMetricsServiceClient> client(
462 new ChromeMetricsServiceClient(state_manager));
463 client->Initialize();
464
465 return client;
466 }
467
468 // static
RegisterPrefs(PrefRegistrySimple * registry)469 void ChromeMetricsServiceClient::RegisterPrefs(PrefRegistrySimple* registry) {
470 metrics::MetricsService::RegisterPrefs(registry);
471 ukm::UkmService::RegisterPrefs(registry);
472 metrics::StabilityMetricsHelper::RegisterPrefs(registry);
473 prefs::RegisterPrivacyBudgetPrefs(registry);
474
475 RegisterFileMetricsPreferences(registry);
476
477 metrics::RegisterMetricsReportingStatePrefs(registry);
478
479 #if BUILDFLAG(ENABLE_PLUGINS)
480 PluginMetricsProvider::RegisterPrefs(registry);
481 #endif // BUILDFLAG(ENABLE_PLUGINS)
482 }
483
GetMetricsService()484 metrics::MetricsService* ChromeMetricsServiceClient::GetMetricsService() {
485 return metrics_service_.get();
486 }
487
GetUkmService()488 ukm::UkmService* ChromeMetricsServiceClient::GetUkmService() {
489 return ukm_service_.get();
490 }
491
SetMetricsClientId(const std::string & client_id)492 void ChromeMetricsServiceClient::SetMetricsClientId(
493 const std::string& client_id) {
494 crash_keys::SetMetricsClientIdFromGUID(client_id);
495 }
496
GetProduct()497 int32_t ChromeMetricsServiceClient::GetProduct() {
498 return metrics::ChromeUserMetricsExtension::CHROME;
499 }
500
GetApplicationLocale()501 std::string ChromeMetricsServiceClient::GetApplicationLocale() {
502 return g_browser_process->GetApplicationLocale();
503 }
504
GetBrand(std::string * brand_code)505 bool ChromeMetricsServiceClient::GetBrand(std::string* brand_code) {
506 return google_brand::GetBrand(brand_code);
507 }
508
GetChannel()509 metrics::SystemProfileProto::Channel ChromeMetricsServiceClient::GetChannel() {
510 return metrics::AsProtobufChannel(chrome::GetChannel());
511 }
512
GetVersionString()513 std::string ChromeMetricsServiceClient::GetVersionString() {
514 return metrics::GetVersionString();
515 }
516
OnEnvironmentUpdate(std::string * environment)517 void ChromeMetricsServiceClient::OnEnvironmentUpdate(std::string* environment) {
518 #if defined(OS_WIN) || defined(OS_MAC) || defined(OS_ANDROID)
519 DCHECK(environment);
520
521 // Register the environment with the crash reporter. Note this only registers
522 // the first environment, meaning ulterior updates to the environment are not
523 // reflected in crash report environments (e.g. fieldtrial information). This
524 // approach is due to the Crashpad API at time of implementation (registered
525 // data cannot be updated). It would however be unwise to rely on such a
526 // mechanism to retrieve the value of the dynamic fields due to the
527 // environment update lag. Also note there is a window from startup to this
528 // point during which crash reports will not have an environment set.
529 if (!g_environment_for_crash_reporter.Get().empty())
530 return;
531
532 g_environment_for_crash_reporter.Get() = std::move(*environment);
533
534 crashpad::CrashpadInfo::GetCrashpadInfo()->AddUserDataMinidumpStream(
535 kSystemProfileMinidumpStreamType,
536 reinterpret_cast<const void*>(
537 g_environment_for_crash_reporter.Get().data()),
538 g_environment_for_crash_reporter.Get().size());
539 #endif // OS_WIN || OS_MAC || OS_ANDROID
540 }
541
CollectFinalMetricsForLog(base::OnceClosure done_callback)542 void ChromeMetricsServiceClient::CollectFinalMetricsForLog(
543 base::OnceClosure done_callback) {
544 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
545
546 collect_final_metrics_done_callback_ = std::move(done_callback);
547 CollectFinalHistograms();
548 }
549
550 std::unique_ptr<metrics::MetricsLogUploader>
CreateUploader(const GURL & server_url,const GURL & insecure_server_url,base::StringPiece mime_type,metrics::MetricsLogUploader::MetricServiceType service_type,const metrics::MetricsLogUploader::UploadCallback & on_upload_complete)551 ChromeMetricsServiceClient::CreateUploader(
552 const GURL& server_url,
553 const GURL& insecure_server_url,
554 base::StringPiece mime_type,
555 metrics::MetricsLogUploader::MetricServiceType service_type,
556 const metrics::MetricsLogUploader::UploadCallback& on_upload_complete) {
557 return std::make_unique<metrics::NetMetricsLogUploader>(
558 g_browser_process->shared_url_loader_factory(), server_url,
559 insecure_server_url, mime_type, service_type, on_upload_complete);
560 }
561
GetStandardUploadInterval()562 base::TimeDelta ChromeMetricsServiceClient::GetStandardUploadInterval() {
563 return metrics::GetUploadInterval(metrics::ShouldUseCellularUploadInterval());
564 }
565
OnPluginLoadingError(const base::FilePath & plugin_path)566 void ChromeMetricsServiceClient::OnPluginLoadingError(
567 const base::FilePath& plugin_path) {
568 #if BUILDFLAG(ENABLE_PLUGINS)
569 plugin_metrics_provider_->LogPluginLoadingError(plugin_path);
570 #else
571 NOTREACHED();
572 #endif // BUILDFLAG(ENABLE_PLUGINS)
573 }
574
IsReportingPolicyManaged()575 bool ChromeMetricsServiceClient::IsReportingPolicyManaged() {
576 return IsMetricsReportingPolicyManaged();
577 }
578
579 metrics::EnableMetricsDefault
GetMetricsReportingDefaultState()580 ChromeMetricsServiceClient::GetMetricsReportingDefaultState() {
581 return metrics::GetMetricsReportingDefaultState(
582 g_browser_process->local_state());
583 }
584
Initialize()585 void ChromeMetricsServiceClient::Initialize() {
586 PrefService* local_state = g_browser_process->local_state();
587
588 metrics_service_ = std::make_unique<metrics::MetricsService>(
589 metrics_state_manager_, this, local_state);
590
591 notification_listeners_active_ = RegisterForNotifications();
592 RegisterMetricsServiceProviders();
593
594 if (IsMetricsReportingForceEnabled() ||
595 base::FeatureList::IsEnabled(ukm::kUkmFeature)) {
596 identifiability_study_state_ =
597 std::make_unique<IdentifiabilityStudyState>(local_state);
598 ukm_service_ = std::make_unique<ukm::UkmService>(
599 local_state, this,
600 MakeDemographicMetricsProvider(
601 metrics::MetricsLogUploader::MetricServiceType::UKM));
602 ukm_service_->SetIsWebstoreExtensionCallback(
603 base::BindRepeating(&IsWebstoreExtension));
604 ukm_service_->RegisterEventFilter(
605 std::make_unique<PrivacyBudgetUkmEntryFilter>(
606 identifiability_study_state_.get()));
607
608 RegisterUKMProviders();
609 }
610
611 #if defined(OS_CHROMEOS)
612 metrics::structured::Recorder::GetInstance()->SetUiTaskRunner(
613 base::SequencedTaskRunnerHandle::Get());
614 #endif
615 }
616
RegisterMetricsServiceProviders()617 void ChromeMetricsServiceClient::RegisterMetricsServiceProviders() {
618 PrefService* local_state = g_browser_process->local_state();
619
620 // Gets access to persistent metrics shared by sub-processes.
621 metrics_service_->RegisterMetricsProvider(
622 std::make_unique<metrics::SubprocessMetricsProvider>());
623
624 #if BUILDFLAG(ENABLE_EXTENSIONS)
625 metrics_service_->RegisterMetricsProvider(
626 std::make_unique<ExtensionsMetricsProvider>(metrics_state_manager_));
627 #endif
628
629 metrics_service_->RegisterMetricsProvider(
630 std::make_unique<metrics::NetworkMetricsProvider>(
631 content::CreateNetworkConnectionTrackerAsyncGetter(),
632 std::make_unique<metrics::NetworkQualityEstimatorProviderImpl>()));
633
634 metrics_service_->RegisterMetricsProvider(
635 std::make_unique<OmniboxMetricsProvider>());
636
637 metrics_service_->RegisterMetricsProvider(
638 std::make_unique<metrics::ContentStabilityMetricsProvider>(
639 local_state, std::make_unique<ChromeMetricsExtensionsHelper>()));
640
641 metrics_service_->RegisterMetricsProvider(
642 std::make_unique<metrics::GPUMetricsProvider>());
643
644 metrics_service_->RegisterMetricsProvider(
645 std::make_unique<metrics::RenderingPerfMetricsProvider>());
646
647 metrics_service_->RegisterMetricsProvider(
648 std::make_unique<metrics::CPUMetricsProvider>());
649
650 metrics_service_->RegisterMetricsProvider(
651 std::make_unique<metrics::EntropyStateProvider>(local_state));
652
653 metrics_service_->RegisterMetricsProvider(
654 std::make_unique<metrics::ScreenInfoMetricsProvider>());
655
656 metrics_service_->RegisterMetricsProvider(CreateFileMetricsProvider(
657 metrics_state_manager_->IsMetricsReportingEnabled()));
658
659 metrics_service_->RegisterMetricsProvider(
660 std::make_unique<metrics::DriveMetricsProvider>(
661 chrome::FILE_LOCAL_STATE));
662
663 metrics_service_->RegisterMetricsProvider(
664 std::make_unique<metrics::CallStackProfileMetricsProvider>());
665
666 metrics_service_->RegisterMetricsProvider(
667 std::make_unique<metrics::SamplingMetricsProvider>());
668
669 metrics_service_->RegisterMetricsProvider(
670 std::make_unique<translate::TranslateRankerMetricsProvider>());
671
672 metrics_service_->RegisterMetricsProvider(
673 std::make_unique<metrics::ComponentMetricsProvider>(
674 g_browser_process->component_updater()));
675
676 metrics_service_->RegisterMetricsProvider(
677 std::make_unique<tracing::BackgroundTracingMetricsProvider>());
678
679 metrics_service_->RegisterMetricsProvider(MakeDemographicMetricsProvider(
680 metrics::MetricsLogUploader::MetricServiceType::UMA));
681
682 #if defined(OS_ANDROID)
683 metrics_service_->RegisterMetricsProvider(
684 std::make_unique<metrics::AndroidMetricsProvider>());
685 metrics_service_->RegisterMetricsProvider(
686 std::make_unique<ChromeAndroidMetricsProvider>());
687 metrics_service_->RegisterMetricsProvider(
688 std::make_unique<PageLoadMetricsProvider>());
689 #endif // defined(OS_ANDROID)
690
691 #if defined(OS_WIN)
692 metrics_service_->RegisterMetricsProvider(
693 std::make_unique<GoogleUpdateMetricsProviderWin>());
694 metrics_service_->RegisterMetricsProvider(
695 std::make_unique<AntiVirusMetricsProvider>());
696 #endif // defined(OS_WIN)
697
698 #if defined(OS_WIN) || defined(OS_MAC) || \
699 (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_BSD)
700 metrics_service_->RegisterMetricsProvider(
701 std::make_unique<DesktopPlatformFeaturesMetricsProvider>());
702 #endif // defined(OS_WIN) || defined(OS_MAC) || \
703 // (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_BSD)
704
705 #if BUILDFLAG(ENABLE_PLUGINS)
706 plugin_metrics_provider_ = new PluginMetricsProvider(local_state);
707 metrics_service_->RegisterMetricsProvider(
708 std::unique_ptr<metrics::MetricsProvider>(plugin_metrics_provider_));
709 #endif // BUILDFLAG(ENABLE_PLUGINS)
710
711 #if BUILDFLAG(IS_LACROS)
712 metrics_service_->RegisterMetricsProvider(
713 std::make_unique<LacrosMetricsProvider>());
714 #endif // BUILDFLAG(IS_LACROS)
715
716 #if defined(OS_CHROMEOS)
717 metrics_service_->RegisterMetricsProvider(
718 std::make_unique<ChromeOSMetricsProvider>(
719 metrics::MetricsLogUploader::UMA));
720
721 if (base::FeatureList::IsEnabled(::features::kUmaStorageDimensions)) {
722 metrics_service_->RegisterMetricsProvider(
723 std::make_unique<CrosHealthdMetricsProvider>());
724 }
725
726 metrics_service_->RegisterMetricsProvider(
727 std::make_unique<SigninStatusMetricsProviderChromeOS>());
728
729 // Record default UMA state as opt-out for all Chrome OS users, if not
730 // recorded yet.
731 if (metrics::GetMetricsReportingDefaultState(local_state) ==
732 metrics::EnableMetricsDefault::DEFAULT_UNKNOWN) {
733 metrics::RecordMetricsReportingDefaultState(
734 local_state, metrics::EnableMetricsDefault::OPT_OUT);
735 }
736
737 metrics_service_->RegisterMetricsProvider(
738 std::make_unique<chromeos::PrinterMetricsProvider>());
739
740 metrics_service_->RegisterMetricsProvider(
741 std::make_unique<metrics::structured::StructuredMetricsProvider>());
742
743 metrics_service_->RegisterMetricsProvider(
744 std::make_unique<AssistantServiceMetricsProvider>());
745
746 metrics_service_->RegisterMetricsProvider(
747 std::make_unique<AmbientModeMetricsProvider>());
748
749 if (base::FeatureList::IsEnabled(chromeos::kFamilyUserMetricsProvider)) {
750 metrics_service_->RegisterMetricsProvider(
751 std::make_unique<FamilyUserMetricsProvider>());
752 }
753
754 if (base::FeatureList::IsEnabled(chromeos::kFamilyLinkUserMetricsProvider)) {
755 metrics_service_->RegisterMetricsProvider(
756 std::make_unique<FamilyLinkUserMetricsProvider>());
757 }
758 #endif // defined(OS_CHROMEOS)
759
760 #if !defined(OS_CHROMEOS)
761 metrics_service_->RegisterMetricsProvider(
762 SigninStatusMetricsProvider::CreateInstance(
763 std::make_unique<ChromeSigninStatusMetricsProviderDelegate>()));
764 // ChromeOS uses ChromeOSMetricsProvider for accessibility metrics provider.
765 metrics_service_->RegisterMetricsProvider(
766 std::make_unique<AccessibilityMetricsProvider>());
767 #endif // !defined(OS_CHROMEOS)
768
769 metrics_service_->RegisterMetricsProvider(
770 std::make_unique<syncer::DeviceCountMetricsProvider>(base::BindRepeating(
771 &DeviceInfoSyncServiceFactory::GetAllDeviceInfoTrackers)));
772
773 metrics_service_->RegisterMetricsProvider(
774 std::make_unique<syncer::PassphraseTypeMetricsProvider>(
775 base::BindRepeating(&ProfileSyncServiceFactory::GetAllSyncServices)));
776
777 metrics_service_->RegisterMetricsProvider(
778 std::make_unique<HttpsEngagementMetricsProvider>());
779
780 metrics_service_->RegisterMetricsProvider(
781 std::make_unique<CertificateReportingMetricsProvider>());
782
783 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
784 metrics_service_->RegisterMetricsProvider(
785 std::make_unique<UpgradeMetricsProvider>());
786 #endif //! defined(OS_ANDROID) && !defined(OS_CHROMEOS)
787
788 #if defined(OS_MAC)
789 metrics_service_->RegisterMetricsProvider(
790 std::make_unique<PowerMetricsProvider>());
791 #endif
792 }
793
RegisterUKMProviders()794 void ChromeMetricsServiceClient::RegisterUKMProviders() {
795 // Note: if you make changes here please also consider whether they should go
796 // in AndroidMetricsServiceClient::CreateUkmService().
797 ukm_service_->RegisterMetricsProvider(
798 std::make_unique<metrics::NetworkMetricsProvider>(
799 content::CreateNetworkConnectionTrackerAsyncGetter(),
800 std::make_unique<metrics::NetworkQualityEstimatorProviderImpl>()));
801
802 #if defined(OS_CHROMEOS)
803 ukm_service_->RegisterMetricsProvider(
804 std::make_unique<ChromeOSMetricsProvider>(
805 metrics::MetricsLogUploader::UKM));
806 #endif // !defined(OS_CHROMEOS)
807
808 ukm_service_->RegisterMetricsProvider(
809 std::make_unique<metrics::GPUMetricsProvider>());
810
811 ukm_service_->RegisterMetricsProvider(
812 std::make_unique<metrics::CPUMetricsProvider>());
813
814 ukm_service_->RegisterMetricsProvider(
815 std::make_unique<metrics::ScreenInfoMetricsProvider>());
816
817 ukm_service_->RegisterMetricsProvider(ukm::CreateFieldTrialsProviderForUkm());
818 }
819
CollectFinalHistograms()820 void ChromeMetricsServiceClient::CollectFinalHistograms() {
821 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
822
823 // Begin the multi-step process of collecting memory usage histograms:
824 // First spawn a task to collect the memory details; when that task is
825 // finished, it will call OnMemoryDetailCollectionDone. That will in turn
826 // call HistogramSynchronization to collect histograms from all renderers and
827 // then call OnHistogramSynchronizationDone to continue processing.
828 DCHECK(!waiting_for_collect_final_metrics_step_);
829 waiting_for_collect_final_metrics_step_ = true;
830
831 base::OnceClosure callback =
832 base::BindOnce(&ChromeMetricsServiceClient::OnMemoryDetailCollectionDone,
833 weak_ptr_factory_.GetWeakPtr());
834
835 auto details =
836 base::MakeRefCounted<MetricsMemoryDetails>(std::move(callback));
837 details->StartFetch();
838 }
839
OnMemoryDetailCollectionDone()840 void ChromeMetricsServiceClient::OnMemoryDetailCollectionDone() {
841 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
842
843 // This function should only be called as the callback from an ansynchronous
844 // step.
845 DCHECK(waiting_for_collect_final_metrics_step_);
846
847 // Create a callback_task for OnHistogramSynchronizationDone.
848 base::RepeatingClosure callback = base::BindRepeating(
849 &ChromeMetricsServiceClient::OnHistogramSynchronizationDone,
850 weak_ptr_factory_.GetWeakPtr());
851
852 base::TimeDelta timeout =
853 base::TimeDelta::FromMilliseconds(kMaxHistogramGatheringWaitDuration);
854
855 DCHECK_EQ(num_async_histogram_fetches_in_progress_, 0);
856
857 #if BUILDFLAG(ENABLE_PRINT_PREVIEW) && !defined(OS_CHROMEOS)
858 num_async_histogram_fetches_in_progress_ = 3;
859 // Run requests to service and content in parallel.
860 if (!ServiceProcessControl::GetInstance()->GetHistograms(callback, timeout)) {
861 // Assume |num_async_histogram_fetches_in_progress_| is not changed by
862 // |GetHistograms()|.
863 DCHECK_EQ(num_async_histogram_fetches_in_progress_, 3);
864 // Assign |num_async_histogram_fetches_in_progress_| above and decrement it
865 // here to make code work even if |GetHistograms()| fired |callback|.
866 --num_async_histogram_fetches_in_progress_;
867 }
868 #else
869 num_async_histogram_fetches_in_progress_ = 2;
870 #endif
871
872 // Merge histograms from metrics providers into StatisticsRecorder.
873 content::GetUIThreadTaskRunner({})->PostTaskAndReply(
874 FROM_HERE,
875 base::BindOnce(&base::StatisticsRecorder::ImportProvidedHistograms),
876 callback);
877
878 // Set up the callback task to call after we receive histograms from all
879 // child processes. |timeout| specifies how long to wait before absolutely
880 // calling us back on the task.
881 content::FetchHistogramsAsynchronously(base::ThreadTaskRunnerHandle::Get(),
882 std::move(callback), timeout);
883 }
884
OnHistogramSynchronizationDone()885 void ChromeMetricsServiceClient::OnHistogramSynchronizationDone() {
886 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
887
888 // This function should only be called as the callback from an ansynchronous
889 // step.
890 DCHECK(waiting_for_collect_final_metrics_step_);
891 DCHECK_GT(num_async_histogram_fetches_in_progress_, 0);
892
893 // Check if all expected requests finished.
894 if (--num_async_histogram_fetches_in_progress_ > 0)
895 return;
896
897 waiting_for_collect_final_metrics_step_ = false;
898 std::move(collect_final_metrics_done_callback_).Run();
899 }
900
RecordCommandLineMetrics()901 void ChromeMetricsServiceClient::RecordCommandLineMetrics() {
902 // Get stats on use of command line.
903 const base::CommandLine* command_line(base::CommandLine::ForCurrentProcess());
904 size_t common_commands = 0;
905 if (command_line->HasSwitch(switches::kUserDataDir)) {
906 ++common_commands;
907 UMA_HISTOGRAM_COUNTS_100("Chrome.CommandLineDatDirCount", 1);
908 }
909
910 if (command_line->HasSwitch(switches::kApp)) {
911 ++common_commands;
912 UMA_HISTOGRAM_COUNTS_100("Chrome.CommandLineAppModeCount", 1);
913 }
914 }
915
RegisterForNotifications()916 bool ChromeMetricsServiceClient::RegisterForNotifications() {
917 registrar_.Add(this, content::NOTIFICATION_LOAD_START,
918 content::NotificationService::AllSources());
919 registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
920 content::NotificationService::AllSources());
921 registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
922 content::NotificationService::AllSources());
923 registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_HANG,
924 content::NotificationService::AllSources());
925 registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
926 content::NotificationService::AllBrowserContextsAndSources());
927
928 omnibox_url_opened_subscription_ =
929 OmniboxEventGlobalTracker::GetInstance()->RegisterCallback(
930 base::BindRepeating(
931 &ChromeMetricsServiceClient::OnURLOpenedFromOmnibox,
932 base::Unretained(this)));
933
934 #if !defined(OS_ANDROID)
935 browser_activity_watcher_ = std::make_unique<BrowserActivityWatcher>(
936 base::BindRepeating(&metrics::MetricsService::OnApplicationNotIdle,
937 base::Unretained(metrics_service_.get())));
938 #endif
939
940 bool all_profiles_succeeded = true;
941 for (Profile* profile :
942 g_browser_process->profile_manager()->GetLoadedProfiles()) {
943 if (!RegisterForProfileEvents(profile)) {
944 all_profiles_succeeded = false;
945 }
946 }
947 return all_profiles_succeeded;
948 }
949
RegisterForProfileEvents(Profile * profile)950 bool ChromeMetricsServiceClient::RegisterForProfileEvents(Profile* profile) {
951 #if defined(OS_CHROMEOS)
952 // Ignore the signin and lock screen app profile for sync disables / history
953 // deletion.
954 if (chromeos::ProfileHelper::IsSigninProfile(profile) ||
955 chromeos::ProfileHelper::IsLockScreenAppProfile(profile)) {
956 // No listeners, but still a success case.
957 return true;
958 }
959
960 // Begin initializing the structured metrics system, which is currently
961 // only implemented for Chrome OS. Initialization must wait until a
962 // profile is added, because it reads keys stored within the user's
963 // cryptohome. We only initialize for profiles that are valid candidates
964 // for metrics collection, ignoring the sign-in profile, lock screen app
965 // profile, and guest sessions.
966 //
967 // TODO(crbug.com/1016655): This conditional would be better placed in
968 // metrics::structured::Recorder, but can't be because it depends on Chrome
969 // code. Investigate whether there's a way of checking this from the
970 // component.
971 if (!profile->IsGuestSession()) {
972 metrics::structured::Recorder::GetInstance()->ProfileAdded(
973 profile->GetPath());
974 }
975 #endif
976 #if defined(OS_WIN) || defined(OS_MAC) || \
977 (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_BSD)
978 // This creates the DesktopProfileSessionDurationsServices if it didn't exist
979 // already.
980 metrics::DesktopProfileSessionDurationsServiceFactory::GetForBrowserContext(
981 profile);
982 #endif
983
984 history::HistoryService* history_service =
985 HistoryServiceFactory::GetForProfile(profile,
986 ServiceAccessType::IMPLICIT_ACCESS);
987 if (!history_service) {
988 return false;
989 }
990
991 ObserveServiceForDeletions(history_service);
992
993 syncer::SyncService* sync = ProfileSyncServiceFactory::GetForProfile(profile);
994 if (!sync) {
995 return false;
996 }
997 StartObserving(sync, profile->GetPrefs());
998 return true;
999 }
1000
Observe(int type,const content::NotificationSource & source,const content::NotificationDetails & details)1001 void ChromeMetricsServiceClient::Observe(
1002 int type,
1003 const content::NotificationSource& source,
1004 const content::NotificationDetails& details) {
1005 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
1006
1007 switch (type) {
1008 case content::NOTIFICATION_LOAD_STOP:
1009 case content::NOTIFICATION_LOAD_START:
1010 case content::NOTIFICATION_RENDERER_PROCESS_CLOSED:
1011 case content::NOTIFICATION_RENDER_WIDGET_HOST_HANG:
1012 metrics_service_->OnApplicationNotIdle();
1013 break;
1014
1015 case chrome::NOTIFICATION_PROFILE_ADDED: {
1016 bool success =
1017 RegisterForProfileEvents(content::Source<Profile>(source).ptr());
1018 // On failure, set |notification_listeners_active_| to false which will
1019 // disable UKM reporting via UpdateRunningServices().
1020 if (!success && notification_listeners_active_) {
1021 notification_listeners_active_ = false;
1022 UpdateRunningServices();
1023 }
1024 break;
1025 }
1026
1027 default:
1028 NOTREACHED();
1029 }
1030 }
1031
OnURLOpenedFromOmnibox(OmniboxLog * log)1032 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
1033 metrics_service_->OnApplicationNotIdle();
1034 }
1035
IsUMACellularUploadLogicEnabled()1036 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
1037 return metrics::ShouldUseCellularUploadInterval();
1038 }
1039
OnHistoryDeleted()1040 void ChromeMetricsServiceClient::OnHistoryDeleted() {
1041 if (ukm_service_)
1042 ukm_service_->Purge();
1043 }
1044
OnUkmAllowedStateChanged(bool must_purge)1045 void ChromeMetricsServiceClient::OnUkmAllowedStateChanged(bool must_purge) {
1046 if (!ukm_service_)
1047 return;
1048 if (must_purge) {
1049 ukm_service_->Purge();
1050 ukm_service_->ResetClientState(ukm::ResetReason::kOnUkmAllowedStateChanged);
1051 } else if (!IsUkmAllowedWithExtensionsForAllProfiles()) {
1052 ukm_service_->PurgeExtensions();
1053 }
1054
1055 // Signal service manager to enable/disable UKM based on new state.
1056 UpdateRunningServices();
1057 }
1058
1059 // static
IsWebstoreExtension(base::StringPiece id)1060 bool ChromeMetricsServiceClient::IsWebstoreExtension(base::StringPiece id) {
1061 #if BUILDFLAG(ENABLE_EXTENSIONS)
1062 // Only acceptable if at least one profile knows the extension and all
1063 // profiles that know the extension say it was from the web-store.
1064 bool matched = false;
1065 ProfileManager* profile_manager = g_browser_process->profile_manager();
1066 DCHECK(profile_manager);
1067 auto profiles = profile_manager->GetLoadedProfiles();
1068 for (Profile* profile : profiles) {
1069 DCHECK(profile);
1070 extensions::ExtensionRegistry* registry =
1071 extensions::ExtensionRegistry::Get(profile);
1072 if (!registry)
1073 continue;
1074 const extensions::Extension* extension = registry->GetExtensionById(
1075 id.as_string(), extensions::ExtensionRegistry::ENABLED);
1076 if (!extension)
1077 continue;
1078 if (!extension->from_webstore())
1079 return false;
1080 matched = true;
1081 }
1082 return matched;
1083 #else
1084 return false;
1085 #endif
1086 }
1087
1088 // static
1089 metrics::FileMetricsProvider::FilterAction
FilterBrowserMetricsFiles(const base::FilePath & path)1090 ChromeMetricsServiceClient::FilterBrowserMetricsFiles(
1091 const base::FilePath& path) {
1092 base::ProcessId pid;
1093 if (!base::GlobalHistogramAllocator::ParseFilePath(path, nullptr, nullptr,
1094 &pid)) {
1095 return metrics::FileMetricsProvider::FILTER_PROCESS_FILE;
1096 }
1097
1098 if (pid == base::GetCurrentProcId())
1099 return metrics::FileMetricsProvider::FILTER_ACTIVE_THIS_PID;
1100
1101 if (IsProcessRunning(pid))
1102 return metrics::FileMetricsProvider::FILTER_TRY_LATER;
1103
1104 return metrics::FileMetricsProvider::FILTER_PROCESS_FILE;
1105 }
1106
1107 // static
SetIsProcessRunningForTesting(ChromeMetricsServiceClient::IsProcessRunningFunction func)1108 void ChromeMetricsServiceClient::SetIsProcessRunningForTesting(
1109 ChromeMetricsServiceClient::IsProcessRunningFunction func) {
1110 g_is_process_running = func;
1111 }
1112
IsUkmAllowedForAllProfiles()1113 bool ChromeMetricsServiceClient::IsUkmAllowedForAllProfiles() {
1114 return UkmConsentStateObserver::IsUkmAllowedForAllProfiles();
1115 }
1116
IsUkmAllowedWithExtensionsForAllProfiles()1117 bool ChromeMetricsServiceClient::IsUkmAllowedWithExtensionsForAllProfiles() {
1118 return UkmConsentStateObserver::IsUkmAllowedWithExtensionsForAllProfiles();
1119 }
1120
1121 bool g_notification_listeners_failed = false;
SetNotificationListenerSetupFailedForTesting(bool simulate_failure)1122 void ChromeMetricsServiceClient::SetNotificationListenerSetupFailedForTesting(
1123 bool simulate_failure) {
1124 g_notification_listeners_failed = simulate_failure;
1125 }
1126
1127 bool ChromeMetricsServiceClient::
AreNotificationListenersEnabledOnAllProfiles()1128 AreNotificationListenersEnabledOnAllProfiles() {
1129 // For testing
1130 if (g_notification_listeners_failed)
1131 return false;
1132 return notification_listeners_active_;
1133 }
1134
GetAppPackageName()1135 std::string ChromeMetricsServiceClient::GetAppPackageName() {
1136 return metrics::GetAppPackageName();
1137 }
1138
GetUploadSigningKey()1139 std::string ChromeMetricsServiceClient::GetUploadSigningKey() {
1140 std::string decoded_key;
1141 base::Base64Decode(google_apis::GetMetricsKey(), &decoded_key);
1142 return decoded_key;
1143 }
1144
ShouldResetClientIdsOnClonedInstall()1145 bool ChromeMetricsServiceClient::ShouldResetClientIdsOnClonedInstall() {
1146 return metrics_service_->ShouldResetClientIdsOnClonedInstall();
1147 }
1148