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