This patch:
- Reformats PseudoStack.h to more closely follow Mozilla style.
- Rewrites some comments to make them more readable, e.g. by properly
delimiting sentences with upper-case letters and full stops.
- Replaces sMin() with std::min(), because <algorithm> no longer causes
problems.
- Reorders PseudoStack so that all the data members are at the end, which makes
them easier to see.
The issue is that with Osaka becoming a downloadable asset rather than a
universally pre-installed font, it's possible for a user's system to be in
a state where the Osaka-Regular face is present (and therefore the Osaka
family shows up in the main font family list), but Osaka-Mono has still not
been downloaded. Until recently, I wasn't aware that the family could be in
that partially-installed state, but apparently it does happen (perhaps
depending on how the download was originally triggered).
The download prompt then occurs when we use LookupLocalFont() to find the
Osaka-Mono face, because that calls CGFontCreateWithFontName, which is
aware of the downloadable font assets; so when it is asked for Osaka-Mono,
and sees that it hasn't been downloaded, it offers to help out.
We tried to avoid this by checking for the presence of the Osaka family
before calling LookupLocalFont(), and that solved things for most users
(where the Osaka family was either fully installed or not installed at
all), but it fails in the case where the Regular face is present but Mono
isn't.
So this patch works around that by avoiding LookupLocalFont (and therefore
CGFontCreateWithFontName) altogether, and instead searching the faces
actually present in the main Osaka family. If Osaka-Mono is installed, it
will be found there and we can then duplicate its font entry and create the
separate Osaka-Mono family; and if not, we safely (and silently) ignore it.
This is fixing two problems.
1) Consider this interface:
[Exposed=(Window,Worker)]
interface Foo {
[Exposed=(Window)]
void someMethod();
};
Without these changes, idlharness will check for a someMethod method on
Foo.prototype in all globals where the Foo interface is exposed, and will fail
in a worker, because someMethod is not exposed there. That's what the blocks
ending with "continue" in IdlInterface.prototype.test_members and
IdlInterface.prototype.test_interface_of fix. This needs the "default_set"
argument to exposure set computation, because if there isn't any exposure set
specified on a member, it gets the exposure set of its interface.
2) Consider this interface:
[Exposed=SharedWorker]
interface Foo {
};
The code without these changes does:
var globals = exposed.length === 1
? exposed[0].rhs.value
: ["Window"];
which sets "globals" to the _string_ "SharedWorker". Then it does
member.exposed = exposed_in(globals). expose_in tries to figure out which sort
of global we're running in. The interesting part is _just_ visible in the
context in the diff. Say we're running in a dedicated worker. Then this test:
if ('DedicatedWorkerGlobalScope' in self &&
self instanceof DedicatedWorkerGlobalScope) {
tests true and this return value:
return globals.indexOf("Worker") >= 0 ||
globals.indexOf("DedicatedWorker") >= 0;
returns true, because if you recall the variable globals is the _string_
"SharedWorker", so globals.indexOf("Worker") >= 0. Yay Python typing.
The fix for this is to make sure that globals ends up as the _list_
["SharedWorker"] in this case, so our indexOf checks in exposed_in do the right
things. That's the:
if (typeof set == "string") {
set = [ set ];
bit.
