1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_dom_PerformanceEventTiming_h___
#define mozilla_dom_PerformanceEventTiming_h___
#include "Performance.h"
#include "mozilla/EventForwards.h"
#include "mozilla/dom/PerformanceEntry.h"
#include "nsINode.h"
#include "nsIWeakReferenceUtils.h"
#include "nsRFPService.h"
namespace mozilla {
class WidgetEvent;
namespace dom {
class PerformanceEventTiming final
: public PerformanceEntry,
public LinkedListElement<RefPtr<PerformanceEventTiming>> {
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PerformanceEventTiming,
PerformanceEntry)
static already_AddRefed<PerformanceEventTiming> TryGenerateEventTiming(
const EventTarget* aTarget, const WidgetEvent* aEvent);
already_AddRefed<PerformanceEventTiming> Clone() {
RefPtr<PerformanceEventTiming> eventTiming =
new PerformanceEventTiming(*this);
return eventTiming.forget();
}
JSObject* WrapObject(JSContext* cx,
JS::Handle<JSObject*> aGivenProto) override;
DOMHighResTimeStamp ProcessingStart() const {
if (mCachedProcessingStart.isNothing()) {
mCachedProcessingStart.emplace(nsRFPService::ReduceTimePrecisionAsMSecs(
mProcessingStart, mPerformance->GetRandomTimelineSeed(),
mPerformance->GetRTPCallerType()));
}
return mCachedProcessingStart.value();
}
DOMHighResTimeStamp ProcessingEnd() const {
if (mCachedProcessingEnd.isNothing()) {
mCachedProcessingEnd.emplace(nsRFPService::ReduceTimePrecisionAsMSecs(
mProcessingEnd, mPerformance->GetRandomTimelineSeed(),
mPerformance->GetRTPCallerType()));
}
return mCachedProcessingEnd.value();
}
bool Cancelable() const { return mCancelable; }
uint64_t InteractionId() const { return mInteractionId.valueOr(0); }
bool HasKnownInteractionId() const { return mInteractionId.isSome(); }
void SetInteractionId(Maybe<uint64_t> aInteractionId) {
mInteractionId = aInteractionId;
}
void SetInteractionId(uint64_t aInteractionId) {
mInteractionId = Some(aInteractionId);
}
nsINode* GetTarget() const;
void SetDuration(const DOMHighResTimeStamp aDuration) {
// Round the duration to the nearest 8ms.
// https://w3c.github.io/event-timing/#set-event-timing-entry-duration
mDuration = std::round(aDuration / 8) * 8;
}
// nsRFPService::ReduceTimePrecisionAsMSecs might causes
// some memory overhead, using the raw timestamp internally
// to avoid calling in unnecessarily.
DOMHighResTimeStamp RawDuration() const { return mDuration; }
DOMHighResTimeStamp Duration() const override {
if (mCachedDuration.isNothing()) {
mCachedDuration.emplace(nsRFPService::ReduceTimePrecisionAsMSecs(
mDuration, mPerformance->GetRandomTimelineSeed(),
mPerformance->GetRTPCallerType()));
}
return mCachedDuration.value();
}
// Similar as RawDuration; Used to avoid calling
// nsRFPService::ReduceTimePrecisionAsMSecs unnecessarily.
DOMHighResTimeStamp RawStartTime() const { return mStartTime; }
DOMHighResTimeStamp StartTime() const override {
if (mCachedStartTime.isNothing()) {
mCachedStartTime.emplace(nsRFPService::ReduceTimePrecisionAsMSecs(
mStartTime, mPerformance->GetRandomTimelineSeed(),
mPerformance->GetRTPCallerType()));
}
return mCachedStartTime.value();
}
bool ShouldAddEntryToBuffer(double aDuration) const;
bool ShouldAddEntryToObserverBuffer(PerformanceObserverInit&) const override;
void BufferEntryIfNeeded() override;
void FinalizeEventTiming(const WidgetEvent* aEvent);
EventMessage GetMessage() const { return mMessage; }
private:
PerformanceEventTiming(Performance* aPerformance, const nsAString& aName,
const TimeStamp& aStartTime, bool aIsCancelable,
EventMessage aMessage);
PerformanceEventTiming(const PerformanceEventTiming& aEventTimingEntry);
~PerformanceEventTiming() = default;
RefPtr<Performance> mPerformance;
DOMHighResTimeStamp mProcessingStart;
mutable Maybe<DOMHighResTimeStamp> mCachedProcessingStart;
DOMHighResTimeStamp mProcessingEnd;
mutable Maybe<DOMHighResTimeStamp> mCachedProcessingEnd;
nsWeakPtr mTarget;
DOMHighResTimeStamp mStartTime;
mutable Maybe<DOMHighResTimeStamp> mCachedStartTime;
DOMHighResTimeStamp mDuration;
mutable Maybe<DOMHighResTimeStamp> mCachedDuration;
bool mCancelable;
Maybe<uint64_t> mInteractionId;
EventMessage mMessage;
};
} // namespace dom
} // namespace mozilla
#endif
|
