accessible/jsat/EventManager.jsm

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 'use strict';
   6
   7 const Ci = Components.interfaces;
   8 const Cu = Components.utils;
   9
  10 const TEXT_NODE = 3;
  11
  12 Cu.import('resource://gre/modules/XPCOMUtils.jsm');
  13 XPCOMUtils.defineLazyModuleGetter(this, 'Services',
  14   'resource://gre/modules/Services.jsm');
  15 XPCOMUtils.defineLazyModuleGetter(this, 'Utils',
  16   'resource://gre/modules/accessibility/Utils.jsm');
  17 XPCOMUtils.defineLazyModuleGetter(this, 'Logger',
  18   'resource://gre/modules/accessibility/Utils.jsm');
  19 XPCOMUtils.defineLazyModuleGetter(this, 'Presentation',
  20   'resource://gre/modules/accessibility/Presentation.jsm');
  21 XPCOMUtils.defineLazyModuleGetter(this, 'TraversalRules',
  22   'resource://gre/modules/accessibility/TraversalRules.jsm');
  23 XPCOMUtils.defineLazyModuleGetter(this, 'Roles',
  24   'resource://gre/modules/accessibility/Constants.jsm');
  25 XPCOMUtils.defineLazyModuleGetter(this, 'Events',
  26   'resource://gre/modules/accessibility/Constants.jsm');
  27 XPCOMUtils.defineLazyModuleGetter(this, 'States',
  28   'resource://gre/modules/accessibility/Constants.jsm');
  29
  30 this.EXPORTED_SYMBOLS = ['EventManager'];
  31
  32 this.EventManager = function EventManager(aContentScope, aContentControl) {
  33   this.contentScope = aContentScope;
  34   this.contentControl = aContentControl;
  35   this.addEventListener = this.contentScope.addEventListener.bind(
  36     this.contentScope);
  37   this.removeEventListener = this.contentScope.removeEventListener.bind(
  38     this.contentScope);
  39   this.sendMsgFunc = this.contentScope.sendAsyncMessage.bind(
  40     this.contentScope);
  41   this.webProgress = this.contentScope.docShell.
  42     QueryInterface(Ci.nsIInterfaceRequestor).
  43     getInterface(Ci.nsIWebProgress);
  44 };
  45
  46 this.EventManager.prototype = {
  47   editState: { editing: false },
  48
  49   start: function start() {
  50     try {
  51       if (!this._started) {
  52         Logger.debug('EventManager.start');
  53
  54         this._started = true;
  55
  56         AccessibilityEventObserver.addListener(this);
  57
  58         this.webProgress.addProgressListener(this,
  59           (Ci.nsIWebProgress.NOTIFY_STATE_ALL |
  60            Ci.nsIWebProgress.NOTIFY_LOCATION));
  61         this.addEventListener('wheel', this, true);
  62         this.addEventListener('scroll', this, true);
  63         this.addEventListener('resize', this, true);
  64       }
  65       this.present(Presentation.tabStateChanged(null, 'newtab'));
  66
  67     } catch (x) {
  68       Logger.logException(x, 'Failed to start EventManager');
  69     }
  70   },
  71
  72   // XXX: Stop is not called when the tab is closed (|TabClose| event is too
  73   // late). It is only called when the AccessFu is disabled explicitly.
  74   stop: function stop() {
  75     if (!this._started) {
  76       return;
  77     }
  78     Logger.debug('EventManager.stop');
  79     AccessibilityEventObserver.removeListener(this);
  80     try {
  81       this.webProgress.removeProgressListener(this);
  82       this.removeEventListener('wheel', this, true);
  83       this.removeEventListener('scroll', this, true);
  84       this.removeEventListener('resize', this, true);
  85     } catch (x) {
  86       // contentScope is dead.
  87     } finally {
  88       this._started = false;
  89     }
  90   },
  91
  92   handleEvent: function handleEvent(aEvent) {
  93     Logger.debug(() => {
  94       return ['DOMEvent', aEvent.type];
  95     });
  96
  97     try {
  98       switch (aEvent.type) {
  99       case 'wheel':
 100       {
 101         let attempts = 0;
 102         let delta = aEvent.deltaX || aEvent.deltaY;
 103         this.contentControl.autoMove(
 104          null,
 105          { moveMethod: delta > 0 ? 'moveNext' : 'movePrevious',
 106            onScreenOnly: true, noOpIfOnScreen: true, delay: 500 });
 107         break;
 108       }
 109       case 'scroll':
 110       case 'resize':
 111       {
 112         // the target could be an element, document or window
 113         let window = null;
 114         if (aEvent.target instanceof Ci.nsIDOMWindow)
 115           window = aEvent.target;
 116         else if (aEvent.target instanceof Ci.nsIDOMDocument)
 117           window = aEvent.target.defaultView;
 118         else if (aEvent.target instanceof Ci.nsIDOMElement)
 119           window = aEvent.target.ownerDocument.defaultView;
 120         this.present(Presentation.viewportChanged(window));
 121         break;
 122       }
 123       }
 124     } catch (x) {
 125       Logger.logException(x, 'Error handling DOM event');
 126     }
 127   },
 128
 129   handleAccEvent: function handleAccEvent(aEvent) {
 130     Logger.debug(() => {
 131       return ['A11yEvent', Logger.eventToString(aEvent),
 132               Logger.accessibleToString(aEvent.accessible)];
 133     });
 134
 135     // Don't bother with non-content events in firefox.
 136     if (Utils.MozBuildApp == 'browser' &&
 137         aEvent.eventType != Events.VIRTUALCURSOR_CHANGED &&
 138         // XXX Bug 442005 results in DocAccessible::getDocType returning
 139         // NS_ERROR_FAILURE. Checking for aEvent.accessibleDocument.docType ==
 140         // 'window' does not currently work.
 141         (aEvent.accessibleDocument.DOMDocument.doctype &&
 142          aEvent.accessibleDocument.DOMDocument.doctype.name === 'window')) {
 143       return;
 144     }
 145
 146     switch (aEvent.eventType) {
 147       case Events.VIRTUALCURSOR_CHANGED:
 148       {
 149         let pivot = aEvent.accessible.
 150           QueryInterface(Ci.nsIAccessibleDocument).virtualCursor;
 151         let position = pivot.position;
 152         if (position && position.role == Roles.INTERNAL_FRAME)
 153           break;
 154         let event = aEvent.
 155           QueryInterface(Ci.nsIAccessibleVirtualCursorChangeEvent);
 156         let reason = event.reason;
 157         let oldAccessible = event.oldAccessible;
 158
 159         if (this.editState.editing &&
 160             !Utils.getState(position).contains(States.FOCUSED)) {
 161           aEvent.accessibleDocument.takeFocus();
 162         }
 163         this.present(
 164           Presentation.pivotChanged(position, oldAccessible, reason,
 165                                     pivot.startOffset, pivot.endOffset,
 166                                     aEvent.isFromUserInput));
 167
 168         break;
 169       }
 170       case Events.STATE_CHANGE:
 171       {
 172         let event = aEvent.QueryInterface(Ci.nsIAccessibleStateChangeEvent);
 173         let state = Utils.getState(event);
 174         if (state.contains(States.CHECKED)) {
 175           this.present(
 176             Presentation.
 177               actionInvoked(aEvent.accessible,
 178                             event.isEnabled ? 'check' : 'uncheck'));
 179         } else if (state.contains(States.SELECTED)) {
 180           this.present(
 181             Presentation.
 182               actionInvoked(aEvent.accessible,
 183                             event.isEnabled ? 'select' : 'unselect'));
 184         }
 185         break;
 186       }
 187       case Events.SCROLLING_START:
 188       {
 189         this.contentControl.autoMove(aEvent.accessible);
 190         break;
 191       }
 192       case Events.TEXT_CARET_MOVED:
 193       {
 194         let acc = aEvent.accessible.QueryInterface(Ci.nsIAccessibleText);
 195         let caretOffset = aEvent.
 196           QueryInterface(Ci.nsIAccessibleCaretMoveEvent).caretOffset;
 197
 198         // We could get a caret move in an accessible that is not focused,
 199         // it doesn't mean we are not on any editable accessible. just not
 200         // on this one..
 201         let state = Utils.getState(acc);
 202         if (state.contains(States.FOCUSED)) {
 203           this._setEditingMode(aEvent, caretOffset);
 204           if (state.contains(States.EDITABLE)) {
 205             this.present(Presentation.textSelectionChanged(acc.getText(0, -1),
 206               caretOffset, caretOffset, 0, 0, aEvent.isFromUserInput));
 207           }
 208         }
 209         break;
 210       }
 211       case Events.OBJECT_ATTRIBUTE_CHANGED:
 212       {
 213         let evt = aEvent.QueryInterface(
 214           Ci.nsIAccessibleObjectAttributeChangedEvent);
 215         if (evt.changedAttribute.toString() !== 'aria-hidden') {
 216           // Only handle aria-hidden attribute change.
 217           break;
 218         }
 219         let hidden = Utils.isHidden(aEvent.accessible);
 220         this[hidden ? '_handleHide' : '_handleShow'](evt);
 221         if (this.inTest) {
 222           this.sendMsgFunc("AccessFu:AriaHidden", { hidden: hidden });
 223         }
 224         break;
 225       }
 226       case Events.SHOW:
 227       {
 228         this._handleShow(aEvent);
 229         break;
 230       }
 231       case Events.HIDE:
 232       {
 233         let evt = aEvent.QueryInterface(Ci.nsIAccessibleHideEvent);
 234         this._handleHide(evt);
 235         break;
 236       }
 237       case Events.TEXT_INSERTED:
 238       case Events.TEXT_REMOVED:
 239       {
 240         let {liveRegion, isPolite} = this._handleLiveRegion(aEvent,
 241           ['text', 'all']);
 242         if (aEvent.isFromUserInput || liveRegion) {
 243           // Handle all text mutations coming from the user or if they happen
 244           // on a live region.
 245           this._handleText(aEvent, liveRegion, isPolite);
 246         }
 247         break;
 248       }
 249       case Events.FOCUS:
 250       {
 251         // Put vc where the focus is at
 252         let acc = aEvent.accessible;
 253         let doc = aEvent.accessibleDocument;
 254         this._setEditingMode(aEvent);
 255         if ([Roles.CHROME_WINDOW,
 256              Roles.DOCUMENT,
 257              Roles.APPLICATION].indexOf(acc.role) < 0) {
 258           this.contentControl.autoMove(acc);
 259        }
 260
 261        if (this.inTest) {
 262         this.sendMsgFunc("AccessFu:Focused");
 263        }
 264        break;
 265       }
 266       case Events.DOCUMENT_LOAD_COMPLETE:
 267       {
 268         let position = this.contentControl.vc.position;
 269         if (aEvent.accessible === aEvent.accessibleDocument ||
 270             (position && Utils.isInSubtree(position, aEvent.accessible))) {
 271           // Do not automove into the document if the virtual cursor is already
 272           // positioned inside it.
 273           break;
 274         }
 275         this.contentControl.autoMove(
 276           aEvent.accessible, { delay: 500 });
 277         break;
 278       }
 279       case Events.VALUE_CHANGE:
 280       {
 281         let position = this.contentControl.vc.position;
 282         let target = aEvent.accessible;
 283         if (position === target ||
 284             Utils.getEmbeddedControl(position) === target) {
 285           this.present(Presentation.valueChanged(target));
 286         }
 287       }
 288     }
 289   },
 290
 291   _setEditingMode: function _setEditingMode(aEvent, aCaretOffset) {
 292     let acc = aEvent.accessible;
 293     let accText, characterCount;
 294     let caretOffset = aCaretOffset;
 295
 296     try {
 297       accText = acc.QueryInterface(Ci.nsIAccessibleText);
 298     } catch (e) {
 299       // No text interface on this accessible.
 300     }
 301
 302     if (accText) {
 303       characterCount = accText.characterCount;
 304       if (caretOffset === undefined) {
 305         caretOffset = accText.caretOffset;
 306       }
 307     }
 308
 309     // Update editing state, both for presenter and other things
 310     let state = Utils.getState(acc);
 311
 312     let editState = {
 313       editing: state.contains(States.EDITABLE) &&
 314         state.contains(States.FOCUSED),
 315       multiline: state.contains(States.MULTI_LINE),
 316       atStart: caretOffset === 0,
 317       atEnd: caretOffset === characterCount
 318     };
 319
 320     // Not interesting
 321     if (!editState.editing && editState.editing === this.editState.editing) {
 322       return;
 323     }
 324
 325     if (editState.editing !== this.editState.editing) {
 326       this.present(Presentation.editingModeChanged(editState.editing));
 327     }
 328
 329     if (editState.editing !== this.editState.editing ||
 330         editState.multiline !== this.editState.multiline ||
 331         editState.atEnd !== this.editState.atEnd ||
 332         editState.atStart !== this.editState.atStart) {
 333       this.sendMsgFunc("AccessFu:Input", editState);
 334     }
 335
 336     this.editState = editState;
 337   },
 338
 339   _handleShow: function _handleShow(aEvent) {
 340     let {liveRegion, isPolite} = this._handleLiveRegion(aEvent,
 341       ['additions', 'all']);
 342     // Only handle show if it is a relevant live region.
 343     if (!liveRegion) {
 344       return;
 345     }
 346     // Show for text is handled by the EVENT_TEXT_INSERTED handler.
 347     if (aEvent.accessible.role === Roles.TEXT_LEAF) {
 348       return;
 349     }
 350     this._dequeueLiveEvent(Events.HIDE, liveRegion);
 351     this.present(Presentation.liveRegion(liveRegion, isPolite, false));
 352   },
 353
 354   _handleHide: function _handleHide(aEvent) {
 355     let {liveRegion, isPolite} = this._handleLiveRegion(
 356       aEvent, ['removals', 'all']);
 357     let acc = aEvent.accessible;
 358     if (liveRegion) {
 359       // Hide for text is handled by the EVENT_TEXT_REMOVED handler.
 360       if (acc.role === Roles.TEXT_LEAF) {
 361         return;
 362       }
 363       this._queueLiveEvent(Events.HIDE, liveRegion, isPolite);
 364     } else {
 365       let vc = Utils.getVirtualCursor(this.contentScope.content.document);
 366       if (vc.position &&
 367         (Utils.getState(vc.position).contains(States.DEFUNCT) ||
 368           Utils.isInSubtree(vc.position, acc))) {
 369         let position = aEvent.targetPrevSibling || aEvent.targetParent;
 370         if (!position) {
 371           try {
 372             position = acc.previousSibling;
 373           } catch (x) {
 374             // Accessible is unattached from the accessible tree.
 375             position = acc.parent;
 376           }
 377         }
 378         this.contentControl.autoMove(position,
 379           { moveToFocused: true, delay: 500 });
 380       }
 381     }
 382   },
 383
 384   _handleText: function _handleText(aEvent, aLiveRegion, aIsPolite) {
 385     let event = aEvent.QueryInterface(Ci.nsIAccessibleTextChangeEvent);
 386     let isInserted = event.isInserted;
 387     let txtIface = aEvent.accessible.QueryInterface(Ci.nsIAccessibleText);
 388
 389     let text = '';
 390     try {
 391       text = txtIface.getText(0, Ci.nsIAccessibleText.TEXT_OFFSET_END_OF_TEXT);
 392     } catch (x) {
 393       // XXX we might have gotten an exception with of a
 394       // zero-length text. If we did, ignore it (bug #749810).
 395       if (txtIface.characterCount) {
 396         throw x;
 397       }
 398     }
 399     // If there are embedded objects in the text, ignore them.
 400     // Assuming changes to the descendants would already be handled by the
 401     // show/hide event.
 402     let modifiedText = event.modifiedText.replace(/\uFFFC/g, '').trim();
 403     if (!modifiedText) {
 404       return;
 405     }
 406     if (aLiveRegion) {
 407       if (aEvent.eventType === Events.TEXT_REMOVED) {
 408         this._queueLiveEvent(Events.TEXT_REMOVED, aLiveRegion, aIsPolite,
 409           modifiedText);
 410       } else {
 411         this._dequeueLiveEvent(Events.TEXT_REMOVED, aLiveRegion);
 412         this.present(Presentation.liveRegion(aLiveRegion, aIsPolite, false,
 413           modifiedText));
 414       }
 415     } else {
 416       this.present(Presentation.textChanged(isInserted, event.start,
 417         event.length, text, modifiedText));
 418     }
 419   },
 420
 421   _handleLiveRegion: function _handleLiveRegion(aEvent, aRelevant) {
 422     if (aEvent.isFromUserInput) {
 423       return {};
 424     }
 425     let parseLiveAttrs = function parseLiveAttrs(aAccessible) {
 426       let attrs = Utils.getAttributes(aAccessible);
 427       if (attrs['container-live']) {
 428         return {
 429           live: attrs['container-live'],
 430           relevant: attrs['container-relevant'] || 'additions text',
 431           busy: attrs['container-busy'],
 432           atomic: attrs['container-atomic'],
 433           memberOf: attrs['member-of']
 434         };
 435       }
 436       return null;
 437     };
 438     // XXX live attributes are not set for hidden accessibles yet. Need to
 439     // climb up the tree to check for them.
 440     let getLiveAttributes = function getLiveAttributes(aEvent) {
 441       let liveAttrs = parseLiveAttrs(aEvent.accessible);
 442       if (liveAttrs) {
 443         return liveAttrs;
 444       }
 445       let parent = aEvent.targetParent;
 446       while (parent) {
 447         liveAttrs = parseLiveAttrs(parent);
 448         if (liveAttrs) {
 449           return liveAttrs;
 450         }
 451         parent = parent.parent
 452       }
 453       return {};
 454     };
 455     let {live, relevant, busy, atomic, memberOf} = getLiveAttributes(aEvent);
 456     // If container-live is not present or is set to |off| ignore the event.
 457     if (!live || live === 'off') {
 458       return {};
 459     }
 460     // XXX: support busy and atomic.
 461
 462     // Determine if the type of the mutation is relevant. Default is additions
 463     // and text.
 464     let isRelevant = Utils.matchAttributeValue(relevant, aRelevant);
 465     if (!isRelevant) {
 466       return {};
 467     }
 468     return {
 469       liveRegion: aEvent.accessible,
 470       isPolite: live === 'polite'
 471     };
 472   },
 473
 474   _dequeueLiveEvent: function _dequeueLiveEvent(aEventType, aLiveRegion) {
 475     let domNode = aLiveRegion.DOMNode;
 476     if (this._liveEventQueue && this._liveEventQueue.has(domNode)) {
 477       let queue = this._liveEventQueue.get(domNode);
 478       let nextEvent = queue[0];
 479       if (nextEvent.eventType === aEventType) {
 480         Utils.win.clearTimeout(nextEvent.timeoutID);
 481         queue.shift();
 482         if (queue.length === 0) {
 483           this._liveEventQueue.delete(domNode)
 484         }
 485       }
 486     }
 487   },
 488
 489   _queueLiveEvent: function _queueLiveEvent(aEventType, aLiveRegion, aIsPolite, aModifiedText) {
 490     if (!this._liveEventQueue) {
 491       this._liveEventQueue = new WeakMap();
 492     }
 493     let eventHandler = {
 494       eventType: aEventType,
 495       timeoutID: Utils.win.setTimeout(this.present.bind(this),
 496         20, // Wait for a possible EVENT_SHOW or EVENT_TEXT_INSERTED event.
 497         Presentation.liveRegion(aLiveRegion, aIsPolite, true, aModifiedText))
 498     };
 499
 500     let domNode = aLiveRegion.DOMNode;
 501     if (this._liveEventQueue.has(domNode)) {
 502       this._liveEventQueue.get(domNode).push(eventHandler);
 503     } else {
 504       this._liveEventQueue.set(domNode, [eventHandler]);
 505     }
 506   },
 507
 508   present: function present(aPresentationData) {
 509     this.sendMsgFunc("AccessFu:Present", aPresentationData);
 510   },
 511
 512   onStateChange: function onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
 513     let tabstate = '';
 514
 515     let loadingState = Ci.nsIWebProgressListener.STATE_TRANSFERRING |
 516       Ci.nsIWebProgressListener.STATE_IS_DOCUMENT;
 517     let loadedState = Ci.nsIWebProgressListener.STATE_STOP |
 518       Ci.nsIWebProgressListener.STATE_IS_NETWORK;
 519
 520     if ((aStateFlags & loadingState) == loadingState) {
 521       tabstate = 'loading';
 522     } else if ((aStateFlags & loadedState) == loadedState &&
 523                !aWebProgress.isLoadingDocument) {
 524       tabstate = 'loaded';
 525     }
 526
 527     if (tabstate) {
 528       let docAcc = Utils.AccRetrieval.getAccessibleFor(aWebProgress.DOMWindow.document);
 529       this.present(Presentation.tabStateChanged(docAcc, tabstate));
 530     }
 531   },
 532
 533   onProgressChange: function onProgressChange() {},
 534
 535   onLocationChange: function onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
 536     let docAcc = Utils.AccRetrieval.getAccessibleFor(aWebProgress.DOMWindow.document);
 537     this.present(Presentation.tabStateChanged(docAcc, 'newdoc'));
 538   },
 539
 540   onStatusChange: function onStatusChange() {},
 541
 542   onSecurityChange: function onSecurityChange() {},
 543
 544   QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener,
 545                                          Ci.nsISupportsWeakReference,
 546                                          Ci.nsISupports,
 547                                          Ci.nsIObserver])
 548 };
 549
 550 const AccessibilityEventObserver = {
 551
 552   /**
 553    * A WeakMap containing [content, EventManager] pairs.
 554    */
 555   eventManagers: new WeakMap(),
 556
 557   /**
 558    * A total number of registered eventManagers.
 559    */
 560   listenerCount: 0,
 561
 562   /**
 563    * An indicator of an active 'accessible-event' observer.
 564    */
 565   started: false,
 566
 567   /**
 568    * Start an AccessibilityEventObserver.
 569    */
 570   start: function start() {
 571     if (this.started || this.listenerCount === 0) {
 572       return;
 573     }
 574     Services.obs.addObserver(this, 'accessible-event', false);
 575     this.started = true;
 576   },
 577
 578   /**
 579    * Stop an AccessibilityEventObserver.
 580    */
 581   stop: function stop() {
 582     if (!this.started) {
 583       return;
 584     }
 585     Services.obs.removeObserver(this, 'accessible-event');
 586     // Clean up all registered event managers.
 587     this.eventManagers.clear();
 588     this.listenerCount = 0;
 589     this.started = false;
 590   },
 591
 592   /**
 593    * Register an EventManager and start listening to the
 594    * 'accessible-event' messages.
 595    *
 596    * @param aEventManager EventManager
 597    *        An EventManager object that was loaded into the specific content.
 598    */
 599   addListener: function addListener(aEventManager) {
 600     let content = aEventManager.contentScope.content;
 601     if (!this.eventManagers.has(content)) {
 602       this.listenerCount++;
 603     }
 604     this.eventManagers.set(content, aEventManager);
 605     // Since at least one EventManager was registered, start listening.
 606     Logger.debug('AccessibilityEventObserver.addListener. Total:',
 607       this.listenerCount);
 608     this.start();
 609   },
 610
 611   /**
 612    * Unregister an EventManager and, optionally, stop listening to the
 613    * 'accessible-event' messages.
 614    *
 615    * @param aEventManager EventManager
 616    *        An EventManager object that was stopped in the specific content.
 617    */
 618   removeListener: function removeListener(aEventManager) {
 619     let content = aEventManager.contentScope.content;
 620     if (!this.eventManagers.delete(content)) {
 621       return;
 622     }
 623     this.listenerCount--;
 624     Logger.debug('AccessibilityEventObserver.removeListener. Total:',
 625       this.listenerCount);
 626     if (this.listenerCount === 0) {
 627       // If there are no EventManagers registered at the moment, stop listening
 628       // to the 'accessible-event' messages.
 629       this.stop();
 630     }
 631   },
 632
 633   /**
 634    * Lookup an EventManager for a specific content. If the EventManager is not
 635    * found, walk up the hierarchy of parent windows.
 636    * @param content Window
 637    *        A content Window used to lookup the corresponding EventManager.
 638    */
 639   getListener: function getListener(content) {
 640     let eventManager = this.eventManagers.get(content);
 641     if (eventManager) {
 642       return eventManager;
 643     }
 644     let parent = content.parent;
 645     if (parent === content) {
 646       // There is no parent or the parent is of a different type.
 647       return null;
 648     }
 649     return this.getListener(parent);
 650   },
 651
 652   /**
 653    * Handle the 'accessible-event' message.
 654    */
 655   observe: function observe(aSubject, aTopic, aData) {
 656     if (aTopic !== 'accessible-event') {
 657       return;
 658     }
 659     let event = aSubject.QueryInterface(Ci.nsIAccessibleEvent);
 660     if (!event.accessibleDocument) {
 661       Logger.warning(
 662         'AccessibilityEventObserver.observe: no accessible document:',
 663         Logger.eventToString(event), "accessible:",
 664         Logger.accessibleToString(event.accessible));
 665       return;
 666     }
 667     let content = event.accessibleDocument.window;
 668     // Match the content window to its EventManager.
 669     let eventManager = this.getListener(content);
 670     if (!eventManager || !eventManager._started) {
 671       if (Utils.MozBuildApp === 'browser' &&
 672           !(content instanceof Ci.nsIDOMChromeWindow)) {
 673         Logger.warning(
 674           'AccessibilityEventObserver.observe: ignored event:',
 675           Logger.eventToString(event), "accessible:",
 676           Logger.accessibleToString(event.accessible), "document:",
 677           Logger.accessibleToString(event.accessibleDocument));
 678       }
 679       return;
 680     }
 681     try {
 682       eventManager.handleAccEvent(event);
 683     } catch (x) {
 684       Logger.logException(x, 'Error handing accessible event');
 685     } finally {
 686       return;
 687     }
 688   }
 689 };