• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2023 The Chromium Authors
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 "components/metrics/structured/test/test_structured_metrics_provider.h"
6 
7 #include "base/files/file_path.h"
8 #include "base/memory/ptr_util.h"
9 #include "base/run_loop.h"
10 #include "base/test/bind.h"
11 #include "components/metrics/structured/test/test_event_storage.h"
12 #include "components/metrics/structured/test/test_key_data_provider.h"
13 
14 namespace metrics::structured {
15 
TestStructuredMetricsProvider()16 TestStructuredMetricsProvider::TestStructuredMetricsProvider() {
17   if (temp_dir_.CreateUniqueTempDir()) {
18     structured_metrics_recorder_ = std::make_unique<StructuredMetricsRecorder>(
19         std::make_unique<TestKeyDataProvider>(
20             temp_dir_.GetPath()
21                 .Append(FILE_PATH_LITERAL("structured_metrics"))
22                 .Append(FILE_PATH_LITERAL("device_keys"))),
23         std::make_unique<TestEventStorage>());
24     structured_metrics_provider_ =
25         base::WrapUnique(new StructuredMetricsProvider(
26             /*write_delay=*/base::Seconds(0),
27             structured_metrics_recorder_.get()));
28     Recorder::GetInstance()->AddObserver(this);
29   }
30 }
31 
TestStructuredMetricsProvider(std::unique_ptr<StructuredMetricsRecorder> recorder)32 TestStructuredMetricsProvider::TestStructuredMetricsProvider(
33     std::unique_ptr<StructuredMetricsRecorder> recorder)
34     : structured_metrics_recorder_(std::move(recorder)) {
35   structured_metrics_provider_ =
36       std::unique_ptr<StructuredMetricsProvider>(new StructuredMetricsProvider(
37           /*write_delay=*/base::Seconds(0),
38           structured_metrics_recorder_.get()));
39   Recorder::GetInstance()->AddObserver(this);
40 }
41 
~TestStructuredMetricsProvider()42 TestStructuredMetricsProvider::~TestStructuredMetricsProvider() {
43   Recorder::GetInstance()->RemoveObserver(this);
44 }
45 
EnableRecording()46 void TestStructuredMetricsProvider::EnableRecording() {
47   structured_metrics_provider_->OnRecordingEnabled();
48 }
49 
DisableRecording()50 void TestStructuredMetricsProvider::DisableRecording() {
51   structured_metrics_provider_->OnRecordingDisabled();
52 }
53 
ReadEvents() const54 const EventsProto& TestStructuredMetricsProvider::ReadEvents() const {
55   return *static_cast<const TestEventStorage*>(
56               structured_metrics_provider_->recorder().event_storage())
57               ->events();
58 }
59 
60 absl::optional<const StructuredEventProto*>
FindEvent(uint64_t project_name_hash,uint64_t event_name_hash)61 TestStructuredMetricsProvider::FindEvent(uint64_t project_name_hash,
62                                          uint64_t event_name_hash) {
63   if (!structured_metrics_provider_->recorder().CanProvideMetrics()) {
64     return absl::nullopt;
65   }
66 
67   const EventsProto& events = TestStructuredMetricsProvider::ReadEvents();
68 
69   for (const auto& event : events.non_uma_events()) {
70     if (event.project_name_hash() == project_name_hash &&
71         event.event_name_hash() == event_name_hash) {
72       return &event;
73     }
74   }
75   return absl::nullopt;
76 }
77 
78 std::vector<const StructuredEventProto*>
FindEvents(uint64_t project_name_hash,uint64_t event_name_hash)79 TestStructuredMetricsProvider::FindEvents(uint64_t project_name_hash,
80                                           uint64_t event_name_hash) {
81   std::vector<const StructuredEventProto*> events_vector;
82   if (!structured_metrics_provider_->recorder().CanProvideMetrics()) {
83     return events_vector;
84   }
85 
86   const EventsProto& events = TestStructuredMetricsProvider::ReadEvents();
87   for (const auto& event : events.non_uma_events()) {
88     if (event.project_name_hash() == project_name_hash &&
89         event.event_name_hash() == event_name_hash) {
90       events_vector.push_back(&event);
91     }
92   }
93   return events_vector;
94 }
95 
SetOnEventsRecordClosure(base::RepeatingCallback<void (const Event & event)> event_record_callback)96 void TestStructuredMetricsProvider::SetOnEventsRecordClosure(
97     base::RepeatingCallback<void(const Event& event)> event_record_callback) {
98   event_record_callback_ = std::move(event_record_callback);
99 }
100 
OnProfileAdded(const base::FilePath & profile_path)101 void TestStructuredMetricsProvider::OnProfileAdded(
102     const base::FilePath& profile_path) {
103   structured_metrics_provider_->recorder().OnProfileAdded(profile_path);
104 }
105 
OnEventRecord(const Event & event)106 void TestStructuredMetricsProvider::OnEventRecord(const Event& event) {
107   structured_metrics_provider_->recorder().OnEventRecord(event);
108   if (!event_record_callback_) {
109     return;
110   }
111 
112   event_record_callback_.Run(event);
113 }
114 
OnReportingStateChanged(bool enabled)115 void TestStructuredMetricsProvider::OnReportingStateChanged(bool enabled) {
116   structured_metrics_provider_->recorder().OnReportingStateChanged(enabled);
117 }
118 
AddProfilePath(const base::FilePath & user_path)119 void TestStructuredMetricsProvider::AddProfilePath(
120     const base::FilePath& user_path) {
121   OnProfileAdded(temp_dir_.GetPath().Append(user_path));
122 }
123 
WaitUntilReady()124 void TestStructuredMetricsProvider::WaitUntilReady() {
125   base::RunLoop run_loop;
126   structured_metrics_provider_->recorder().SetOnReadyToRecord(
127       base::BindLambdaForTesting([&run_loop]() { run_loop.Quit(); }));
128   run_loop.Run();
129 }
130 
131 }  // namespace metrics::structured
132