Link to issue number:

None.

Summary of the issue:

Firefox is adding support for out-of-process iframes; i.e. iframes rendered in a separate process to their embedder document. For an out-of-process iframe, the embedder has no knowledge of children in the embedded document and cannot communicate with the embedded document at all. This means that accChild for accessibles in the embedded document fails. This requires some changes to the gecko_ia2 virtual buffer.

Description of how this pull request fixes the issue:

In the gecko_ia2 vbuf:

1. getNVDAObjectFromIdentifier: Use getNVDAObjectFromEvent instead of accChild on the document. This was changed last year to use accChild on the document in the theoretical hope that it might be slightly faster, since it doesn't need to go via the parent process. However, this was never proved to be a performance benefit in real terms. The root accessible is in the parent process and can fetch children in all content documents, so using AccessibleObjectFromEvent works as expected.
2. __contains__: If accChild fails, get the embedder iframe and try accChild with the iframe's id. There can be nested out-of-process iframes, so we keep trying this until there are no more embedders in the hierarchy (or until we hit the buffer's root id).

Testing performed:

1. Loaded a document with two out-of-process iframes in one tab and a document with no iframes in another tab. In the Python console, saved the former document's TreeInterceptor as ti1 and the latter document's TreeInterceptor as ti2; e.g. ti1 = nav.treeInterceptor.
2. Moved the navigator object to a node in the innermost iframe and pressed NVDA+control+z to take a console snapshot.
3. Confirmed that nav in ti1 is True and nav in ti2 is False.
4. Moved the navigator object to a node in the document with no iframes and pressed NVDA+control+z.
5. Confirmed that nav in ti1 is False and nav in ti2 is True.

Also used a build with this change for a while doing some daily browsing with Gmail, GitHub, etc.

Known issues with pull request:

There will be some additional COM calls for objects in out-of-process iframes. However, there don't tend to be many levels of nested iframes, so I don't anticipate this will be a significant issue in reality.

Other avenues explored:

Originally, I tried having __contains__ check the buffer itself to see if it contains the node in question. This also had to check ancestors (limited at an arbitrary number for performance) just in case the buffer hasn't caught up yet or in case we chose not to render descendants in the buffer.

1. I was uncomfortable with the arbitrary ancestor check limit, even though it's necessary for performance. With the new approach, we don't have to worry about performance as much because iframes generally aren't nested deeply (whereas nodes on a page often are).
2. This approach caused major problems when a buffer was being loaded. I didn't dig into this much, but I guess the buffer was reporting that nodes didn't exist (which makes total sense while it's loading). This would certainly confuse things because the focus would be reported as not being within the buffer.

Change log entry:

Changes:

- Support for out-of-process iframes in Mozilla Firefox.