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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/* -*- 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 nsJSEnvironment_h
#define nsJSEnvironment_h
#include "nsIScriptContext.h"
#include "nsIScriptGlobalObject.h"
#include "nsCOMPtr.h"
#include "prtime.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIArray.h"
#include "mozilla/Attributes.h"
#include "mozilla/TimeStamp.h"
#include "nsThreadUtils.h"
#include "xpcpublic.h"
class nsICycleCollectorListener;
class nsIDocShell;
namespace mozilla {
template <class>
class Maybe;
struct CycleCollectorResults;
static const uint32_t kMajorForgetSkippableCalls = 5;
} // namespace mozilla
class nsJSContext : public nsIScriptContext {
public:
nsJSContext(bool aGCOnDestruction, nsIScriptGlobalObject* aGlobalObject);
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsJSContext,
nsIScriptContext)
virtual nsIScriptGlobalObject* GetGlobalObject() override;
inline nsIScriptGlobalObject* GetGlobalObjectRef() {
return mGlobalObjectRef;
}
virtual nsresult SetProperty(JS::Handle<JSObject*> aTarget,
const char* aPropName,
nsISupports* aVal) override;
virtual bool GetProcessingScriptTag() override;
virtual void SetProcessingScriptTag(bool aResult) override;
virtual nsresult InitClasses(JS::Handle<JSObject*> aGlobalObj) override;
virtual void SetWindowProxy(JS::Handle<JSObject*> aWindowProxy) override;
virtual JSObject* GetWindowProxy() override;
enum IsShrinking { ShrinkingGC, NonShrinkingGC };
// Setup all the statics etc - safe to call multiple times after Startup().
static void EnsureStatics();
static void SetLowMemoryState(bool aState);
static void GarbageCollectNow(JS::GCReason reason,
IsShrinking aShrinking = NonShrinkingGC);
static void RunIncrementalGCSlice(JS::GCReason aReason,
IsShrinking aShrinking,
js::SliceBudget& aBudget);
static void CycleCollectNow(mozilla::CCReason aReason,
nsICycleCollectorListener* aListener = nullptr);
// Finish up any in-progress incremental GC.
static void PrepareForCycleCollectionSlice(mozilla::CCReason aReason,
mozilla::TimeStamp aDeadline);
// Run a cycle collector slice, using a heuristic to decide how long to run
// it.
static void RunCycleCollectorSlice(mozilla::CCReason aReason,
mozilla::TimeStamp aDeadline);
// Run a cycle collector slice, using the given work budget.
static void RunCycleCollectorWorkSlice(int64_t aWorkBudget);
static void BeginCycleCollectionCallback(mozilla::CCReason aReason);
static void EndCycleCollectionCallback(
const mozilla::CycleCollectorResults& aResults);
// Return the longest CC slice time since ClearMaxCCSliceTime() was last
// called.
static uint32_t GetMaxCCSliceTimeSinceClear();
static void ClearMaxCCSliceTime();
// If there is some pending CC or GC timer/runner, this will run it.
static void RunNextCollectorTimer(
JS::GCReason aReason,
mozilla::TimeStamp aDeadline = mozilla::TimeStamp());
// If user has been idle and aDocShell is for an iframe being loaded in an
// already loaded top level docshell, this will run a CC or GC
// timer/runner if there is such pending.
static void MaybeRunNextCollectorSlice(nsIDocShell* aDocShell,
JS::GCReason aReason);
// The GC should run soon, in the zone of aObj if given. If aObj is
// nullptr, collect all Zones.
static void PokeGC(JS::GCReason aReason, JSObject* aObj,
mozilla::TimeDuration aDelay = 0);
// If usage is nearing a threshold, request idle-only GC work. (This is called
// when a collection would be relatively convenient.)
static void MaybePokeGC();
// Immediately perform a non-incremental shrinking GC and CC.
static void DoLowMemoryGC();
// Perform a non-incremental shrinking GC and CC according to
// IdleScheduler.
static void LowMemoryGC();
static void MaybePokeCC();
// Calling LikelyShortLivingObjectCreated() makes a GC more likely.
static void LikelyShortLivingObjectCreated();
static bool HasHadCleanupSinceLastGC();
nsIScriptGlobalObject* GetCachedGlobalObject() {
// Verify that we have a global so that this
// does always return a null when GetGlobalObject() is null.
JSObject* global = GetWindowProxy();
return global ? mGlobalObjectRef.get() : nullptr;
}
protected:
virtual ~nsJSContext();
// Helper to convert xpcom datatypes to jsvals.
nsresult ConvertSupportsTojsvals(JSContext* aCx, nsISupports* aArgs,
JS::Handle<JSObject*> aScope,
JS::MutableHandleVector<JS::Value> aArgsOut);
nsresult AddSupportsPrimitiveTojsvals(JSContext* aCx, nsISupports* aArg,
JS::Value* aArgv);
private:
void Destroy();
JS::Heap<JSObject*> mWindowProxy;
bool mGCOnDestruction;
bool mProcessingScriptTag;
// mGlobalObjectRef ensures that the outer window stays alive as long as the
// context does. It is eventually collected by the cycle collector.
nsCOMPtr<nsIScriptGlobalObject> mGlobalObjectRef;
static bool DOMOperationCallback(JSContext* cx);
};
namespace mozilla::dom {
class SerializedStackHolder;
void StartupJSEnvironment();
void ShutdownJSEnvironment();
// Runnable that's used to do async error reporting
class AsyncErrorReporter final : public mozilla::Runnable {
public:
explicit AsyncErrorReporter(xpc::ErrorReport* aReport);
// SerializeStack is suitable for main or worklet thread use.
// Stacks from worker threads are not supported.
// See https://bugzilla.mozilla.org/show_bug.cgi?id=1578968
void SerializeStack(JSContext* aCx, JS::Handle<JSObject*> aStack);
// Set the exception value associated with this error report.
// Should only be called from the main thread.
void SetException(JSContext* aCx, JS::Handle<JS::Value> aException);
protected:
NS_IMETHOD Run() override;
// This is only used on main thread!
JS::PersistentRooted<JS::Value> mException;
bool mHasException = false;
RefPtr<xpc::ErrorReport> mReport;
// This may be used to marshal a stack from an arbitrary thread/runtime into
// the main thread/runtime where the console service runs.
UniquePtr<SerializedStackHolder> mStackHolder;
};
} // namespace mozilla::dom
// An interface for fast and native conversion to/from nsIArray. If an object
// supports this interface, JS can reach directly in for the argv, and avoid
// nsISupports conversion. If this interface is not supported, the object will
// be queried for nsIArray, and everything converted via xpcom objects.
#define NS_IJSARGARRAY_IID \
{ \
0xb6acdac8, 0xf5c6, 0x432c, { \
0xa8, 0x6e, 0x33, 0xee, 0xb1, 0xb0, 0xcd, 0xdc \
} \
}
class nsIJSArgArray : public nsIArray {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IJSARGARRAY_IID)
// Bug 312003 describes why this must be "void **", but after calling argv
// may be cast to JS::Value* and the args found at:
// ((JS::Value*)argv)[0], ..., ((JS::Value*)argv)[argc - 1]
virtual nsresult GetArgs(uint32_t* argc, void** argv) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIJSArgArray, NS_IJSARGARRAY_IID)
#endif /* nsJSEnvironment_h */
|
