1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/metrics/events_metrics_manager.h"
#include <utility>
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "cc/metrics/event_metrics.h"
namespace cc {
class EventsMetricsManager::ScopedMonitorImpl
: public EventsMetricsManager::ScopedMonitor {
public:
ScopedMonitorImpl(EventsMetricsManager* manager, DoneCallback done_callback)
: manager_(manager), done_callback_(std::move(done_callback)) {
DCHECK(manager_);
}
~ScopedMonitorImpl() override {
if (manager_)
End();
}
void End() {
DCHECK(manager_);
std::unique_ptr<EventMetrics> metrics;
if (!done_callback_.is_null()) {
const bool handled = save_metrics_;
metrics = std::move(done_callback_).Run(handled);
// If `handled` is false, the callback should return nullptr.
DCHECK(handled || !metrics);
}
manager_->OnScopedMonitorEnded(std::move(metrics));
manager_ = nullptr;
}
// Overridden from EventsMetricsManager::ScopedMonitor.
void SetSaveMetrics() override { save_metrics_ = true; }
private:
raw_ptr<EventsMetricsManager> manager_;
DoneCallback done_callback_;
bool save_metrics_ = false;
};
EventsMetricsManager::ScopedMonitor::ScopedMonitor() = default;
EventsMetricsManager::ScopedMonitor::~ScopedMonitor() = default;
EventsMetricsManager::EventsMetricsManager() = default;
EventsMetricsManager::~EventsMetricsManager() {
// If `EventsMetricsManager` is shut down while events are active, end active
// scoped monitors immediately.
while (!active_scoped_monitors_.empty())
active_scoped_monitors_.back()->End();
}
std::unique_ptr<EventsMetricsManager::ScopedMonitor>
EventsMetricsManager::GetScopedMonitor(
ScopedMonitor::DoneCallback done_callback) {
auto monitor =
std::make_unique<ScopedMonitorImpl>(this, std::move(done_callback));
active_scoped_monitors_.push_back(monitor.get());
return monitor;
}
void EventsMetricsManager::SaveActiveEventMetrics() {
if (active_scoped_monitors_.size() > 0) {
// Here we just set the flag to save the active metrics. The actual saving
// happens when the scoped monitor is destroyed to give clients opportunity
// to use/update the metrics object until the end of their processing.
active_scoped_monitors_.back()->SetSaveMetrics();
}
}
EventMetrics::List EventsMetricsManager::TakeSavedEventsMetrics() {
EventMetrics::List result;
result.swap(saved_events_);
return result;
}
void EventsMetricsManager::OnScopedMonitorEnded(
std::unique_ptr<EventMetrics> metrics) {
DCHECK_GT(active_scoped_monitors_.size(), 0u);
active_scoped_monitors_.pop_back();
if (metrics) {
if (metrics->type() == EventMetrics::EventType::kGestureScrollUpdate ||
metrics->type() == EventMetrics::EventType::kFirstGestureScrollUpdate ||
metrics->type() ==
EventMetrics::EventType::kInertialGestureScrollUpdate) {
auto* scroll_update = metrics->AsScrollUpdate();
scroll_update->set_did_scroll(did_scroll_);
}
saved_events_.push_back(std::move(metrics));
}
did_scroll_ = false;
}
} // namespace cc
|
