A user account is required in order to edit this wiki, but we've had to disable public user registrations due to spam.

To request an account, ask an autoconfirmed user on IRC (such as one of these permanent autoconfirmed members).


From WHATWG Wiki
Revision as of 15:32, 13 August 2011 by Annevk (talk | contribs) (experiment)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
Immediately After modifications End of current task New task
  • It's conceptually the easiest thing to understand. The following *always* hold:
    • For calling code: When any DOM operation I make completes, all observers will have run.
    • For notified code: If I'm being called, the operation which caused this is below me on the stack.
  • It's conceptually close to fully synchronous. For simple uses (specifically, setting aside the case of making DOM operations within a mutation callback), it has the advantages of Option 1, without its disadvantages. Because of this, it's similar to the behavior of current Mutation Events.
  • Semantics are consistent: delivery happens right before the outermost DOM operation returns.
  • Easier transition from mutation events to the new API.
  • Not bound to tasks. Side effects, like problems related to spinning event loop are per mutation callback, not per whole task.
  • No code is at risk for having its assumptions invalidated while it is trying to do work. All participants (main application script, libraries which are implemented using DOM mutation observation) are allowed to complete whatever work (DOM operations) they wish before another participant starts doing work.
  • Can batch more, since the callbacks are called later than in option 2.
  • Conceptually easy to understand
  • Easy to implement.
Con Because mutations must be delivered for some DOM operations before the operation is complete, UAs must tolerate all ways in which script may invalidate their assumptions before they do further work. Since the approach is bound to tasks, it is not clear what should happen if event loop spins while handling the task. What if some other task modifies the DOM, when should the mutation callbacks fire? Because of this issue, tasks, which may spin event loop, should not also modify DOM since that may cause some unexpected result.

Callback handling is moved far away from the actual mutation.

It's too late. Most use cases for mutation observation require that observers run before a paint occurs. E.g. a widget library which watches for special attributes. Script may create a
and an observer will react to this by decorating the div as a FooButton. It is unacceptable (creates visual artifacts/flickering) to have the div be painted before the widget library has decorated it as a FooButton.

Both of these options appear to be non-starters. Option 1 has been shown by experience to be an unreasonable implementation burden for UAs. Option 4 clearly doesn't handle properly important use cases.