Move editor's key event listener, xbl commands, and typeahead find into the system event group. This allows event listeners in content to reliably cancel key events. Bug 54035, r=jkeiser and aaronl, sr=hyatt and kin.

content/xbl/src/nsXBLBinding.cpp

@@ -90,6 +90,7 @@
 #include "nsIDOMDragListener.h"
 #include "nsIDOMMutationListener.h"
 #include "nsIDOMContextMenuListener.h"
+#include "nsIDOMEventGroup.h"
 
 #include "nsXBLAtoms.h"
 #include "nsXULAtoms.h"
@@ -860,6 +861,14 @@ nsXBLBinding::InstallEventHandlers()
       PRBool found = PR_FALSE;
       GetEventHandlerIID(eventAtom, &iid, &found);
 
+      // If this is a command, add it in the system event group, otherwise 
+      // add it to the standard event group.
+
+      nsCOMPtr<nsIDOM3EventTarget> target = do_QueryInterface(receiver);
+      nsCOMPtr<nsIDOMEventGroup> eventGroup;
+      if (curr->GetType() & NS_HANDLER_TYPE_XBL_COMMAND)
+        receiver->GetSystemEventGroup(getter_AddRefs(eventGroup));
+
       if (found) { 
         /*
         // Disable ATTACHTO capability for Mozilla 1.0
@@ -887,78 +896,101 @@ nsXBLBinding::InstallEventHandlers()
         }
         */
 
-        // Add the event listener.
         if (iid.Equals(NS_GET_IID(nsIDOMMouseListener))) {
           nsXBLMouseHandler* mouseHandler;
           NS_NewXBLMouseHandler(receiver, curr, &mouseHandler);
-          receiver->AddEventListener(type, (nsIDOMMouseListener*)mouseHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMMouseListener*)mouseHandler,
+                                          useCapture, eventGroup);
           handler = mouseHandler;
         }
         else if(iid.Equals(NS_GET_IID(nsIDOMKeyListener))) {
           nsXBLKeyHandler* keyHandler;
           NS_NewXBLKeyHandler(receiver, curr, &keyHandler);
-          receiver->AddEventListener(type, (nsIDOMKeyListener*)keyHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMKeyListener*)keyHandler,
+                                          useCapture, eventGroup);
           handler = keyHandler;
         }
         else if (iid.Equals(NS_GET_IID(nsIDOMMouseMotionListener))) {
           nsXBLMouseMotionHandler* mouseHandler;
           NS_NewXBLMouseMotionHandler(receiver, curr, &mouseHandler);
-          receiver->AddEventListener(type, (nsIDOMMouseListener*)mouseHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMMouseListener*)mouseHandler,
+                                          useCapture, eventGroup);
           handler = mouseHandler;
         }
         else if(iid.Equals(NS_GET_IID(nsIDOMFocusListener))) {
           nsXBLFocusHandler* focusHandler;
           NS_NewXBLFocusHandler(receiver, curr, &focusHandler);
-          receiver->AddEventListener(type, (nsIDOMFocusListener*)focusHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMFocusListener*)focusHandler,
+                                          useCapture, eventGroup);
           handler = focusHandler;
         }
         else if (iid.Equals(NS_GET_IID(nsIDOMXULListener))) {
           nsXBLXULHandler* xulHandler;
           NS_NewXBLXULHandler(receiver, curr, &xulHandler);
-          receiver->AddEventListener(type, (nsIDOMXULListener*)xulHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                           (nsIDOMXULListener*)xulHandler,
+                                           useCapture, eventGroup);
           handler = xulHandler;
         }
         else if (iid.Equals(NS_GET_IID(nsIDOMScrollListener))) {
           nsXBLScrollHandler* scrollHandler;
           NS_NewXBLScrollHandler(receiver, curr, &scrollHandler);
-          receiver->AddEventListener(type, (nsIDOMScrollListener*)scrollHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMScrollListener*)scrollHandler,
+                                          useCapture, eventGroup);
           handler = scrollHandler;
         }
         else if (iid.Equals(NS_GET_IID(nsIDOMFormListener))) {
           nsXBLFormHandler* formHandler;
           NS_NewXBLFormHandler(receiver, curr, &formHandler);
-          receiver->AddEventListener(type, (nsIDOMFormListener*)formHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMFormListener*)formHandler,
+                                          useCapture, eventGroup);
           handler = formHandler;
         }
         else if(iid.Equals(NS_GET_IID(nsIDOMDragListener))) {
           nsXBLDragHandler* dragHandler;
           NS_NewXBLDragHandler(receiver, curr, &dragHandler);
-          receiver->AddEventListener(type, (nsIDOMDragListener*)dragHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMDragListener*)dragHandler,
+                                          useCapture, eventGroup);
           handler = dragHandler;
         }
         else if(iid.Equals(NS_GET_IID(nsIDOMLoadListener))) {
           nsXBLLoadHandler* loadHandler;
           NS_NewXBLLoadHandler(receiver, curr, &loadHandler);
-          receiver->AddEventListener(type, (nsIDOMLoadListener*)loadHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMLoadListener*)loadHandler,
+                                          useCapture, eventGroup);
           handler = loadHandler;
         }
         else if(iid.Equals(NS_GET_IID(nsIDOMMutationListener))) {
           nsXBLMutationHandler* mutationHandler;
           NS_NewXBLMutationHandler(receiver, curr, &mutationHandler);
-          receiver->AddEventListener(type, (nsIDOMMutationListener*)mutationHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMMutationListener*)mutationHandler,
+                                          useCapture, eventGroup);
           handler = mutationHandler;
         }
         else if(iid.Equals(NS_GET_IID(nsIDOMContextMenuListener))) {
           nsXBLContextMenuHandler* menuHandler;
           NS_NewXBLContextMenuHandler(receiver, curr, &menuHandler);
-          receiver->AddEventListener(type, (nsIDOMContextMenuListener*)menuHandler, useCapture);
+          target->AddGroupedEventListener(type,
+                                          (nsIDOMContextMenuListener*)menuHandler,
+                                          useCapture, eventGroup);
           handler = menuHandler;
         }
       }
       else {
         nsXBLCustomHandler* customHandler;
         NS_NewXBLCustomHandler(receiver, curr, &customHandler);
-        receiver->AddEventListener(type, (nsIDOMEventListener*)customHandler, useCapture);
+        target->AddGroupedEventListener(type,
+                                        (nsIDOMEventListener*)customHandler,
+                                        useCapture, eventGroup);
         handler = customHandler;
       }
 

content/xbl/src/nsXBLEventHandler.cpp

@@ -75,6 +75,8 @@
 #include "nsIDOMScrollListener.h"
 #include "nsIDOMFormListener.h"
 #include "nsXBLAtoms.h"
+#include "nsIDOMEventGroup.h"
+#include "nsIDOM3EventTarget.h"
 
 nsXBLEventHandler::nsXBLEventHandler(nsIDOMEventReceiver* aEventReceiver,
                                      nsXBLPrototypeHandler* aHandler)
@@ -114,8 +116,15 @@ nsXBLEventHandler::RemoveEventHandlers()
 
   nsCOMPtr<nsIDOMEventListener> listener(do_QueryInterface(this));
 
-  if (found && listener)
-    mEventReceiver->RemoveEventListener(type, listener, useCapture);
+  // are we in the system event group?
+  nsCOMPtr<nsIDOMEventGroup> eventGroup;
+  if (mProtoHandler->GetType() & NS_HANDLER_TYPE_XBL_COMMAND)
+    mEventReceiver->GetSystemEventGroup(getter_AddRefs(eventGroup));
+
+  if (found && listener) {
+    nsCOMPtr<nsIDOM3EventTarget> target = do_QueryInterface(mEventReceiver);
+    target->RemoveGroupedEventListener(type, listener, useCapture, eventGroup);
+  }
 }
 
 /// Helpers that are relegated to the end of the file /////////////////////////////

content/xbl/src/nsXBLPrototypeHandler.h

@@ -84,6 +84,7 @@ public:
   void AppendHandlerText(const nsAString& aText);
 
   PRUint8 GetPhase() { return mPhase; }
+  PRUint8 GetType() { return mType; }
 
   nsXBLPrototypeHandler* GetNextHandler() { return mNextHandler; }
   void SetNextHandler(nsXBLPrototypeHandler* aHandler) { mNextHandler = aHandler; }

content/xbl/src/nsXBLService.cpp

@@ -89,6 +89,7 @@
 
 #include "nsIXULPrototypeCache.h"
 #include "nsIDOMLoadListener.h"
+#include "nsIDOMEventGroup.h"
 
 // Static IIDs/CIDs. Try to minimize these.
 static NS_DEFINE_CID(kXMLDocumentCID,             NS_XMLDOCUMENT_CID);
@@ -737,9 +738,16 @@ nsXBLService::AttachGlobalKeyHandler(nsIDOMEventReceiver* aReceiver)
     return NS_ERROR_FAILURE;
 
   // listen to these events
-  rec->AddEventListener(NS_LITERAL_STRING("keydown"), handler, PR_FALSE);
-  rec->AddEventListener(NS_LITERAL_STRING("keyup"), handler, PR_FALSE);
-  rec->AddEventListener(NS_LITERAL_STRING("keypress"), handler, PR_FALSE);
+  nsCOMPtr<nsIDOMEventGroup> systemGroup;
+  rec->GetSystemEventGroup(getter_AddRefs(systemGroup));
+  nsCOMPtr<nsIDOM3EventTarget> target = do_QueryInterface(rec);
+
+  target->AddGroupedEventListener(NS_LITERAL_STRING("keydown"), handler,
+                                  PR_FALSE, systemGroup);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("keyup"), handler, 
+                                  PR_FALSE, systemGroup);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("keypress"), handler, 
+                                  PR_FALSE, systemGroup);
 
   // Release.  Do this so that only the event receiver holds onto the key handler.
   NS_RELEASE(handler);
@@ -763,12 +771,21 @@ nsXBLService::AttachGlobalDragHandler(nsIDOMEventReceiver* aReceiver)
   if (!handler)
     return NS_ERROR_FAILURE;
 
+  nsCOMPtr<nsIDOMEventGroup> systemGroup;
+  aReceiver->GetSystemEventGroup(getter_AddRefs(systemGroup));
+  nsCOMPtr<nsIDOM3EventTarget> target = do_QueryInterface(aReceiver);
+
   // listen to these events
-  aReceiver->AddEventListener(NS_LITERAL_STRING("draggesture"), handler, PR_FALSE);
-  aReceiver->AddEventListener(NS_LITERAL_STRING("dragenter"), handler, PR_FALSE);
-  aReceiver->AddEventListener(NS_LITERAL_STRING("dragexit"), handler, PR_FALSE);
-  aReceiver->AddEventListener(NS_LITERAL_STRING("dragover"), handler, PR_FALSE);
-  aReceiver->AddEventListener(NS_LITERAL_STRING("dragdrop"), handler, PR_FALSE);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("draggesture"), handler,
+                                  PR_FALSE, systemGroup);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("dragenter"), handler,
+                                  PR_FALSE, systemGroup);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("dragexit"), handler,
+                                  PR_FALSE, systemGroup);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("dragover"), handler,
+                                  PR_FALSE, systemGroup);
+  target->AddGroupedEventListener(NS_LITERAL_STRING("dragdrop"), handler,
+                                  PR_FALSE, systemGroup);
 
   // Release.  Do this so that only the event receiver holds onto the handler.
   NS_RELEASE(handler);

editor/libeditor/text/nsEditorEventListeners.cpp

@@ -304,7 +304,8 @@ nsTextEditorKeyListener::KeyPress(nsIDOMEvent* aKeyEvent)
     }
   }
 
-  textEditor->HandleKeyPress(keyEvent);
+  if (isSystemPass)
+    textEditor->HandleKeyPress(keyEvent);
 
   return NS_OK; // we don't PreventDefault() here or keybindings like control-x won't work 
 }

extensions/typeaheadfind/src/nsTypeAheadFind.cpp

@@ -108,6 +108,8 @@
 #include "nsIPrivateCompositionEvent.h"
 #include "nsGUIEvent.h"
 #include "nsIDOMEventReceiver.h"
+#include "nsIDOM3EventTarget.h"
+#include "nsIDOMEventGroup.h"
 
 // Header for this class
 #include "nsTypeAheadFind.h"
@@ -2248,9 +2250,14 @@ nsTypeAheadFind::RemoveWindowListeners(nsIDOMWindow *aDOMWin)
   }
 
   // Use capturing, otherwise the normal find next will get activated when ours should
-  chromeEventHandler->RemoveEventListener(NS_LITERAL_STRING("keypress"),
-                                          NS_STATIC_CAST(nsIDOMKeyListener*, this),
-                                          PR_FALSE);
+  nsCOMPtr<nsIDOMEventReceiver> receiver(do_QueryInterface(chromeEventHandler));
+  nsCOMPtr<nsIDOMEventGroup> systemGroup;
+  receiver->GetSystemEventGroup(getter_AddRefs(systemGroup));
+  nsCOMPtr<nsIDOM3EventTarget> target(do_QueryInterface(receiver));
+
+  target->RemoveGroupedEventListener(NS_LITERAL_STRING("keypress"),
+                                     NS_STATIC_CAST(nsIDOMKeyListener*, this),
+                                     PR_FALSE, systemGroup);
 
   if (aDOMWin == mFocusedWindow) {
     mFocusedWindow = nsnull;
@@ -2296,9 +2303,14 @@ nsTypeAheadFind::AttachWindowListeners(nsIDOMWindow *aDOMWin)
   }
 
   // Use capturing, otherwise the normal find next will get activated when ours should
-  chromeEventHandler->AddEventListener(NS_LITERAL_STRING("keypress"),
-                                       NS_STATIC_CAST(nsIDOMKeyListener*, this),
-                                       PR_FALSE);
+  nsCOMPtr<nsIDOMEventReceiver> receiver(do_QueryInterface(chromeEventHandler));
+  nsCOMPtr<nsIDOMEventGroup> systemGroup;
+  receiver->GetSystemEventGroup(getter_AddRefs(systemGroup));
+  nsCOMPtr<nsIDOM3EventTarget> target(do_QueryInterface(receiver));
+
+  target->AddGroupedEventListener(NS_LITERAL_STRING("keypress"),
+                                  NS_STATIC_CAST(nsIDOMKeyListener*, this),
+                                  PR_FALSE, systemGroup);
 
   // Attach menu listeners, this will help us ignore keystrokes meant for menus
   nsIDOMEventListener *genericEventListener =