The preview also causes a ruleview-changed event to be emitted. If the frame
script happened to detect the change fast enough, the test would continue to
commit the value and start to wait for a ruleview-changed event. If the event
triggered by the preview had not been emitted, the test would continue
immediately once the event triggered by the preview was received but before
the value was actually committed and reflected in the computed rule list.
The fix is to wait for the ruleview-changed triggered by the preview before
committing the change to avoid mixing these two events.
FindFreeEntry() has one caller, so using MOZ_ALWAYS_INLINE should be good
enough for it. As for SearchTable(), NS_FASTCALL is the same as
PL_DHASH_FASTCALL and so can be used instead.
--HG--
extra : rebase_source : 814f96d4751922785358e7a4f9d64fcf522364c1
We no longer update UUIDs when changing XPIDL interfaces. `mach
update-uuids` was invented to make this process easier. Delete the
command and related code since it is no longer needed.
--HG--
extra : commitid : GLChZKelC0Q
extra : rebase_source : f4a8f9727f1213ae4fe5d17fa1a648ed8802095f
extra : amend_source : 2fdab014f16482ae82e0cc0f9b2c2f4620001657
Since Uint32 can't be represented in a MIRType_Int32, this function should
return a MIRType_Double.
Allow MSimdExtractElement(Uint32x4) to return a MIRType_Int32 too. It will work
like the double version followed by MTruncateToInt32 which bitcasts the Uint32
value range into the Int32 value range.
Add a MSimdBinaryComp::AddLegalized function which expands unsigned compares on
target platforms that don't support them directly. The early expansion exposes
the constants to MIR optimizations.
Unsigned comparison is expressed in terms of signed comparison by offsetting
both sides by INT_MIN.
The conversion from Uint32x4 to Float32x4 is not available as an SSE
instruction, so we need to expand into a larger instruction sequence lifted
from LLVM. Make this expansion early when generating MIR so that it can be
exposed to LICM and GVN optimizations.
The conversion from Float32x4 to Uint32x4 can throw a RangeError. It is handled
similarly to LFloat32x4ToInt32x4. This expansion depends on the details of the
cvttps2dq instruction that can't be expressed in MIR, so it can't be expanded
early.
Add a new InlinableNative::SimdUint32x4 enumerator, and emit the corresponding
JSJitInfo objects in SIMD.cpp.
Start producing template objects for Uint32x4 operations in BaselineIC.cpp.
Add a new SimdSign enum class to SIMD.h which will be used to distinguish
between signed and unsigned integers in the few places where it matters.
Map the SIMD.Uint32x4 type to the existing MIRType_Int32x4 + SimdSign::Unsigned.
Map SIMD.Int32x4 to MITType_Int32x4 + SimdSign::Signed.
Add a 'SimdSign sign' argument to those inlineSimd...() functions that care.
Some MIR instructions will get similar fields in the following commits.
For now, abort inlining if unsigned vectors are actually encountered. These cases
will be fixed in the following commits.
Extract the code that generates template objects for SIMD operations, and
rewrite it to use the JSJitInfo nativeOp encoding.
This avoids the native function pointer comparisons, and it makes it simpler to
add new SIMD types and operations.
The extractLane(), anyTrue(), and allTrue() SIMD functions produce scalar
values, and so they don't need a template object. The canInlineSimd() function
was rejecting these functions because of the missing template object.
At the same time, explicitly avoid inlining any SIMD operations if the JIT does
not support SIMD. This was previously controlled by the absense of the template
object.
This saves some code size in a cold function, and it makes it possible to pass
in the SIMD type as a dynamic argument.
Also detemplatize the static CreateSimdType() to save some code size.
Replace all of the Get*TypeRepr() self-hosting functions with a single
GetSimdTypeDescr() which takes one of the JS_SIMDTYPEREPR_* constants as an
argument instead.
Total code shrink ~ 32 KB.
Remove obsolete SIZE_CHANGED event and its handler in nsWindow. Also
remove some other supporting code (such as gAndroidBounds and the
FORCED_RESIZE event) that should be unnecessary by now.
Convert the SIZE_CHANGED event to a native method in GLController, and
carry over the SIZE_CHANGED implementation to the new implementation in
GLController. Some other changes were made for correctness in handling
size changes.
Right now, we rely on browser.js sending Gecko:Ready, to set the
GeckoThread state to RUNNING upon receiving Gecko:Ready. This patch
gets rid of this dependency on browser.js and Gecko:Ready.
Convert the old prefs code in browser.js to use observer notifications
that are sent by the new PrefsHelper implementation, in order to handle
pseudo-prefs.
Implement the PrefsHelper native methods. The previous browser.js
implementation supported "pseudo-prefs" that did not exist as actual
prefs, but was accessible through PrefsHelper. In order to accommodate
these pseudo-prefs, we send observer notifications in order to
communicate with browser.js about prefs that we don't support.
Introduce a new implementation for PrefsHelper that does not use events
or rely on browser.js for getting and/or setting prefs. Also add an
addObserver method to better match the removeObserver method.
What it does:
Adds a new function, TelemetrySession.getChildThreadHangs(), which returns a promise resolving to an array of threadHangStats [1], one per process.
Note that processes that spawn or die while the function's promise is created but not resolved may be excluded from the final result.
How we do this:
1. Parent sends a MESSAGE_TELEMETRY_GET_CHILD_PAYLOAD message to each child, promising the results of these messages.
2. Child processes respond to parent with a MESSAGE_TELEMETRY_THREAD_HANGS, which contains BHR stats in the payload.
3. Parent combines all the child responses together and resolves the promise.
Plus a bunch of synchronization stuff and handling of edge cases since the number of child processes can change at any time.
Also, there is a 200ms timeout since we can't handle all of these cases. Specifically, when a child dies without responding, after all other child processes have responded.
Why we do this:
* We can technically get thread hang stats by retrieving Telemetry pings (see requestChildPayloads() in TelemetrySession for details), but this is very slow and can only be done for one process at a time.
* TelemetrySession is responsible for various Telemetry IPC-related tasks, and so is a natural place to expose this function (i.e., the function blends in well with the rest of the API).
* Statuser [2] uses this for quickly obtaining child process BHR stats. This allows us to get realtime hang monitoring for child processes.
[1]: https://dxr.mozilla.org/mozilla-central/source/toolkit/components/telemetry/nsITelemetry.idl#146
[2]: https://github.com/chutten/statuser