LCOV - app.info - content/events/src/nsDOMEvent.cpp

LCOV - code coverage report
| Current view: | directory - content/events/src - nsDOMEvent.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 744 | 155 | 20.8 %
| Date: | 2012-06-02 | Functions: | 53 | 28 | 52.8 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Steve Clark (buster@netscape.com)
          24                 :  *   Ilya Konstantinov (mozilla-code@future.shiny.co.il)
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          28                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : #include "base/basictypes.h"
          41                 :
          42                 : /* This must occur *after* base/basictypes.h to avoid typedefs conflicts. */
          43                 : #include "mozilla/Util.h"
          44                 :
          45                 : #include "IPC/IPCMessageUtils.h"
          46                 : #include "nsCOMPtr.h"
          47                 : #include "nsDOMEvent.h"
          48                 : #include "nsEventStateManager.h"
          49                 : #include "nsIFrame.h"
          50                 : #include "nsIContent.h"
          51                 : #include "nsIPresShell.h"
          52                 : #include "nsIDocument.h"
          53                 : #include "nsIInterfaceRequestor.h"
          54                 : #include "nsIInterfaceRequestorUtils.h"
          55                 : #include "prmem.h"
          56                 : #include "nsGkAtoms.h"
          57                 : #include "nsMutationEvent.h"
          58                 : #include "nsContentUtils.h"
          59                 : #include "nsIURI.h"
          60                 : #include "nsIScriptSecurityManager.h"
          61                 : #include "nsIScriptError.h"
          62                 : #include "nsDOMPopStateEvent.h"
          63                 : #include "mozilla/Preferences.h"
          64                 : #include "nsJSUtils.h"
          65                 : #include "DictionaryHelpers.h"
          66                 : #include "nsLayoutUtils.h"
          67                 : #include "nsIScrollableFrame.h"
          68                 :
          69                 : using namespace mozilla;
          70                 :
          71                 : static const char* const sEventNames[] = {
          72                 :   "mousedown", "mouseup", "click", "dblclick", "mouseenter", "mouseleave", "mouseover",
          73                 :   "mouseout", "MozMouseHittest", "mousemove", "contextmenu", "keydown", "keyup", "keypress",
          74                 :   "focus", "blur", "load", "popstate", "beforescriptexecute",
          75                 :   "afterscriptexecute", "beforeunload", "unload",
          76                 :   "hashchange", "readystatechange", "abort", "error",
          77                 :   "submit", "reset", "change", "select", "input", "invalid", "text",
          78                 :   "compositionstart", "compositionend", "compositionupdate",
          79                 :   "popupshowing", "popupshown",
          80                 :   "popuphiding", "popuphidden", "close", "command", "broadcast", "commandupdate",
          81                 :   "dragenter", "dragover", "dragexit", "dragdrop", "draggesture",
          82                 :   "drag", "dragend", "dragstart", "dragleave", "drop", "resize",
          83                 :   "scroll", "overflow", "underflow", "overflowchanged",
          84                 :   "DOMSubtreeModified", "DOMNodeInserted", "DOMNodeRemoved",
          85                 :   "DOMNodeRemovedFromDocument", "DOMNodeInsertedIntoDocument",
          86                 :   "DOMAttrModified", "DOMCharacterDataModified",
          87                 :   "DOMActivate", "DOMFocusIn", "DOMFocusOut",
          88                 :   "pageshow", "pagehide", "DOMMouseScroll", "MozMousePixelScroll",
          89                 :   "offline", "online", "copy", "cut", "paste", "open", "message", "show",
          90                 :   "SVGLoad", "SVGUnload", "SVGAbort", "SVGError", "SVGResize", "SVGScroll",
          91                 :   "SVGZoom",
          92                 :   "beginEvent", "endEvent", "repeatEvent",
          93                 : #ifdef MOZ_MEDIA
          94                 :   "loadstart", "progress", "suspend", "emptied", "stalled", "play", "pause",
          95                 :   "loadedmetadata", "loadeddata", "waiting", "playing", "canplay",
          96                 :   "canplaythrough", "seeking", "seeked", "timeupdate", "ended", "ratechange",
          97                 :   "durationchange", "volumechange", "MozAudioAvailable",
          98                 : #endif // MOZ_MEDIA
          99                 :   "MozAfterPaint",
         100                 :   "MozBeforeResize",
         101                 :   "mozfullscreenchange",
         102                 :   "mozfullscreenerror",
         103                 :   "MozSwipeGesture",
         104                 :   "MozMagnifyGestureStart",
         105                 :   "MozMagnifyGestureUpdate",
         106                 :   "MozMagnifyGesture",
         107                 :   "MozRotateGestureStart",
         108                 :   "MozRotateGestureUpdate",
         109                 :   "MozRotateGesture",
         110                 :   "MozTapGesture",
         111                 :   "MozPressTapGesture",
         112                 :   "MozTouchDown",
         113                 :   "MozTouchMove",
         114                 :   "MozTouchUp",
         115                 :   "touchstart",
         116                 :   "touchend",
         117                 :   "touchmove",
         118                 :   "touchcancel",
         119                 :   "touchenter",
         120                 :   "touchleave",
         121                 :   "MozScrolledAreaChanged",
         122                 :   "transitionend",
         123                 :   "animationstart",
         124                 :   "animationend",
         125                 :   "animationiteration",
         126                 :   "devicemotion",
         127                 :   "deviceorientation"
         128                 : };
         129                 :
         130                 : static char *sPopupAllowedEvents;
         131                 :
         132                 :
         133           16413 : nsDOMEvent::nsDOMEvent(nsPresContext* aPresContext, nsEvent* aEvent)
         134                 : {
         135           16413 :   mPrivateDataDuplicated = false;
         136                 :
         137           16413 :   if (aEvent) {
         138              46 :     mEvent = aEvent;
         139              46 :     mEventIsInternal = false;
         140                 :   }
         141                 :   else {
         142           16367 :     mEventIsInternal = true;
         143                 :     /*
         144                 :       A derived class might want to allocate its own type of aEvent
         145                 :       (derived from nsEvent). To do this, it should take care to pass
         146                 :       a non-NULL aEvent to this ctor, e.g.:
         147                 :
         148                 :         nsDOMFooEvent::nsDOMFooEvent(..., nsEvent* aEvent)
         149                 :         : nsDOMEvent(..., aEvent ? aEvent : new nsFooEvent())
         150                 :
         151                 :       Then, to override the mEventIsInternal assignments done by the
         152                 :       base ctor, it should do this in its own ctor:
         153                 :
         154                 :         nsDOMFooEvent::nsDOMFooEvent(..., nsEvent* aEvent)
         155                 :         ...
         156                 :         {
         157                 :           ...
         158                 :           if (aEvent) {
         159                 :             mEventIsInternal = false;
         160                 :           }
         161                 :           else {
         162                 :             mEventIsInternal = true;
         163                 :           }
         164                 :           ...
         165                 :         }
         166                 :      */
         167           16367 :     mEvent = new nsEvent(false, 0);
         168           16367 :     mEvent->time = PR_Now();
         169                 :   }
         170                 :
         171           16413 :   InitPresContextData(aPresContext);
         172                 :
         173           16413 :   NS_ASSERTION(mEvent->message != NS_PAINT, "Trying to create a DOM paint event!");
         174           16413 : }
         175                 :
         176                 : void
         177           16413 : nsDOMEvent::InitPresContextData(nsPresContext* aPresContext)
         178                 : {
         179           16413 :   mPresContext = aPresContext;
         180                 :   // Get the explicit original target (if it's anonymous make it null)
         181                 :   {
         182           32826 :     nsCOMPtr<nsIContent> content = GetTargetFromFrame();
         183           16413 :     mExplicitOriginalTarget = do_QueryInterface(content);
         184           16413 :     if (content && content->IsInAnonymousSubtree()) {
         185               0 :       mExplicitOriginalTarget = nsnull;
         186                 :     }
         187                 :   }
         188           16413 : }
         189                 :
         190           46824 : nsDOMEvent::~nsDOMEvent()
         191                 : {
         192           16413 :   NS_ASSERT_OWNINGTHREAD(nsDOMEvent);
         193                 :
         194           16413 :   if (mEventIsInternal && mEvent) {
         195           16367 :     delete mEvent;
         196                 :   }
         197           60822 : }
         198                 :
         199            1464 : NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMEvent)
         200                 :
         201                 : DOMCI_DATA(Event, nsDOMEvent)
         202                 :
         203          194013 : NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDOMEvent)
         204          120654 :   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMEvent)
         205          116674 :   NS_INTERFACE_MAP_ENTRY(nsIDOMEvent)
         206           75019 :   NS_INTERFACE_MAP_ENTRY(nsIDOMNSEvent)
         207           60198 :   NS_INTERFACE_MAP_ENTRY(nsIPrivateDOMEvent)
         208           19033 :   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
         209           19033 :   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Event)
         210           15663 : NS_INTERFACE_MAP_END
         211                 :
         212          109375 : NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMEvent)
         213          109375 : NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMEvent)
         214                 :
         215              11 : NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDOMEvent)
         216              11 :   if (tmp->mEventIsInternal) {
         217              11 :     tmp->mEvent->target = nsnull;
         218              11 :     tmp->mEvent->currentTarget = nsnull;
         219              11 :     tmp->mEvent->originalTarget = nsnull;
         220              11 :     switch (tmp->mEvent->eventStructType) {
         221                 :       case NS_MOUSE_EVENT:
         222                 :       case NS_MOUSE_SCROLL_EVENT:
         223                 :       case NS_SIMPLE_GESTURE_EVENT:
         224                 :       case NS_MOZTOUCH_EVENT:
         225               0 :         static_cast<nsMouseEvent_base*>(tmp->mEvent)->relatedTarget = nsnull;
         226               0 :         break;
         227                 :       case NS_DRAG_EVENT:
         228               0 :         static_cast<nsDragEvent*>(tmp->mEvent)->dataTransfer = nsnull;
         229               0 :         static_cast<nsMouseEvent_base*>(tmp->mEvent)->relatedTarget = nsnull;
         230               0 :         break;
         231                 :       case NS_MUTATION_EVENT:
         232               0 :         static_cast<nsMutationEvent*>(tmp->mEvent)->mRelatedNode = nsnull;
         233               0 :         break;
         234                 :       default:
         235              11 :         break;
         236                 :     }
         237                 :   }
         238              11 :   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mPresContext);
         239              11 :   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mExplicitOriginalTarget);
         240              11 : NS_IMPL_CYCLE_COLLECTION_UNLINK_END
         241                 :
         242              34 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsDOMEvent)
         243              34 :   if (tmp->mEventIsInternal) {
         244              34 :     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mEvent->target)
         245              34 :     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mEvent->currentTarget)
         246              34 :     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mEvent->originalTarget)
         247              34 :     switch (tmp->mEvent->eventStructType) {
         248                 :       case NS_MOUSE_EVENT:
         249                 :       case NS_MOUSE_SCROLL_EVENT:
         250                 :       case NS_SIMPLE_GESTURE_EVENT:
         251                 :       case NS_MOZTOUCH_EVENT:
         252               0 :         NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mEvent->relatedTarget");
         253                 :         cb.NoteXPCOMChild(
         254               0 :           static_cast<nsMouseEvent_base*>(tmp->mEvent)->relatedTarget);
         255               0 :         break;
         256                 :       case NS_DRAG_EVENT:
         257               0 :         NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mEvent->dataTransfer");
         258                 :         cb.NoteXPCOMChild(
         259               0 :           static_cast<nsDragEvent*>(tmp->mEvent)->dataTransfer);
         260               0 :         NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mEvent->relatedTarget");
         261                 :         cb.NoteXPCOMChild(
         262               0 :           static_cast<nsMouseEvent_base*>(tmp->mEvent)->relatedTarget);
         263               0 :         break;
         264                 :       case NS_MUTATION_EVENT:
         265               0 :         NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mEvent->mRelatedNode");
         266                 :         cb.NoteXPCOMChild(
         267               0 :           static_cast<nsMutationEvent*>(tmp->mEvent)->mRelatedNode);
         268               0 :         break;
         269                 :       default:
         270              34 :         break;
         271                 :     }
         272                 :   }
         273              34 :   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_MEMBER(mPresContext.get(), nsPresContext)
         274              34 :   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mExplicitOriginalTarget)
         275              34 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
         276                 :
         277                 : // nsIDOMEventInterface
         278             148 : NS_METHOD nsDOMEvent::GetType(nsAString& aType)
         279                 : {
         280             148 :   if (!mCachedType.IsEmpty()) {
         281             148 :     aType = mCachedType;
         282             148 :     return NS_OK;
         283                 :   }
         284               0 :   const char* name = GetEventName(mEvent->message);
         285                 :
         286               0 :   if (name) {
         287               0 :     CopyASCIItoUTF16(name, aType);
         288               0 :     mCachedType = aType;
         289               0 :     return NS_OK;
         290               0 :   } else if (mEvent->message == NS_USER_DEFINED_EVENT && mEvent->userType) {
         291               0 :     aType = Substring(nsDependentAtomString(mEvent->userType), 2); // Remove "on"
         292               0 :     mCachedType = aType;
         293               0 :     return NS_OK;
         294                 :   }
         295                 :
         296               0 :   aType.Truncate();
         297               0 :   return NS_OK;
         298                 : }
         299                 :
         300                 : static nsresult
         301            7502 : GetDOMEventTarget(nsIDOMEventTarget* aTarget,
         302                 :                   nsIDOMEventTarget** aDOMTarget)
         303                 : {
         304                 :   nsIDOMEventTarget* realTarget =
         305            7502 :     aTarget ? aTarget->GetTargetForDOMEvent() : aTarget;
         306                 :
         307            7502 :   NS_IF_ADDREF(*aDOMTarget = realTarget);
         308                 :
         309            7502 :   return NS_OK;
         310                 : }
         311                 :
         312                 : NS_METHOD
         313            3537 : nsDOMEvent::GetTarget(nsIDOMEventTarget** aTarget)
         314                 : {
         315            3537 :   return GetDOMEventTarget(mEvent->target, aTarget);
         316                 : }
         317                 :
         318                 : NS_IMETHODIMP
         319            3965 : nsDOMEvent::GetCurrentTarget(nsIDOMEventTarget** aCurrentTarget)
         320                 : {
         321            3965 :   return GetDOMEventTarget(mEvent->currentTarget, aCurrentTarget);
         322                 : }
         323                 :
         324                 : //
         325                 : // Get the actual event target node (may have been retargeted for mouse events)
         326                 : //
         327                 : already_AddRefed<nsIContent>
         328           16413 : nsDOMEvent::GetTargetFromFrame()
         329                 : {
         330           16413 :   if (!mPresContext) { return nsnull; }
         331                 :
         332                 :   // Get the target frame (have to get the ESM first)
         333               0 :   nsIFrame* targetFrame = mPresContext->EventStateManager()->GetEventTarget();
         334               0 :   if (!targetFrame) { return nsnull; }
         335                 :
         336                 :   // get the real content
         337               0 :   nsCOMPtr<nsIContent> realEventContent;
         338               0 :   targetFrame->GetContentForEvent(mEvent, getter_AddRefs(realEventContent));
         339               0 :   return realEventContent.forget();
         340                 : }
         341                 :
         342                 : NS_IMETHODIMP
         343               0 : nsDOMEvent::GetExplicitOriginalTarget(nsIDOMEventTarget** aRealEventTarget)
         344                 : {
         345               0 :   if (mExplicitOriginalTarget) {
         346               0 :     *aRealEventTarget = mExplicitOriginalTarget;
         347               0 :     NS_ADDREF(*aRealEventTarget);
         348               0 :     return NS_OK;
         349                 :   }
         350                 :
         351               0 :   return GetTarget(aRealEventTarget);
         352                 : }
         353                 :
         354                 : NS_IMETHODIMP
         355               0 : nsDOMEvent::GetOriginalTarget(nsIDOMEventTarget** aOriginalTarget)
         356                 : {
         357               0 :   if (mEvent->originalTarget) {
         358               0 :     return GetDOMEventTarget(mEvent->originalTarget, aOriginalTarget);
         359                 :   }
         360                 :
         361               0 :   return GetTarget(aOriginalTarget);
         362                 : }
         363                 :
         364                 : NS_IMETHODIMP
         365           16381 : nsDOMEvent::SetTrusted(bool aTrusted)
         366                 : {
         367           16381 :   if (aTrusted) {
         368           16381 :     mEvent->flags |= NS_EVENT_FLAG_TRUSTED;
         369                 :   } else {
         370               0 :     mEvent->flags &= ~NS_EVENT_FLAG_TRUSTED;
         371                 :   }
         372                 :
         373           16381 :   return NS_OK;
         374                 : }
         375                 :
         376                 : NS_IMETHODIMP
         377               0 : nsDOMEvent::Initialize(nsISupports* aOwner, JSContext* aCx, JSObject* aObj,
         378                 :                        PRUint32 aArgc, jsval* aArgv)
         379                 : {
         380               0 :   NS_ENSURE_TRUE(aArgc >= 1, NS_ERROR_XPC_NOT_ENOUGH_ARGS);
         381                 :
         382               0 :   bool trusted = false;
         383               0 :   nsCOMPtr<nsPIDOMWindow> w = do_QueryInterface(aOwner);
         384               0 :   if (w) {
         385               0 :     nsCOMPtr<nsIDocument> d = do_QueryInterface(w->GetExtantDocument());
         386               0 :     if (d) {
         387               0 :       trusted = nsContentUtils::IsChromeDoc(d);
         388               0 :       nsIPresShell* s = d->GetShell();
         389               0 :       if (s) {
         390               0 :         InitPresContextData(s->GetPresContext());
         391                 :       }
         392                 :     }
         393                 :   }
         394                 :
         395               0 :   JSAutoRequest ar(aCx);
         396               0 :   JSString* jsstr = JS_ValueToString(aCx, aArgv[0]);
         397               0 :   if (!jsstr) {
         398               0 :     return NS_ERROR_DOM_SYNTAX_ERR;
         399                 :   }
         400                 :
         401               0 :   JS::Anchor<JSString*> deleteProtector(jsstr);
         402                 :
         403               0 :   nsDependentJSString type;
         404               0 :   NS_ENSURE_STATE(type.init(aCx, jsstr));
         405                 :
         406               0 :   nsresult rv = InitFromCtor(type, aCx, aArgc >= 2 ? &(aArgv[1]) : nsnull);
         407               0 :   NS_ENSURE_SUCCESS(rv, rv);
         408                 :
         409               0 :   SetTrusted(trusted);
         410               0 :   return NS_OK;
         411                 : }
         412                 :
         413                 : nsresult
         414               0 : nsDOMEvent::InitFromCtor(const nsAString& aType,
         415                 :                          JSContext* aCx, jsval* aVal)
         416                 : {
         417               0 :   mozilla::dom::EventInit d;
         418               0 :   nsresult rv = d.Init(aCx, aVal);
         419               0 :   NS_ENSURE_SUCCESS(rv, rv);
         420               0 :   return InitEvent(aType, d.bubbles, d.cancelable);
         421                 : }
         422                 :
         423                 : NS_IMETHODIMP
         424               0 : nsDOMEvent::GetEventPhase(PRUint16* aEventPhase)
         425                 : {
         426                 :   // Note, remember to check that this works also
         427                 :   // if or when Bug 235441 is fixed.
         428               0 :   if (mEvent->currentTarget == mEvent->target ||
         429                 :       ((mEvent->flags & NS_EVENT_FLAG_CAPTURE) &&
         430                 :        (mEvent->flags & NS_EVENT_FLAG_BUBBLE))) {
         431               0 :     *aEventPhase = nsIDOMEvent::AT_TARGET;
         432               0 :   } else if (mEvent->flags & NS_EVENT_FLAG_CAPTURE) {
         433               0 :     *aEventPhase = nsIDOMEvent::CAPTURING_PHASE;
         434               0 :   } else if (mEvent->flags & NS_EVENT_FLAG_BUBBLE) {
         435               0 :     *aEventPhase = nsIDOMEvent::BUBBLING_PHASE;
         436                 :   } else {
         437               0 :     *aEventPhase = 0;
         438                 :   }
         439               0 :   return NS_OK;
         440                 : }
         441                 :
         442                 : NS_IMETHODIMP
         443               0 : nsDOMEvent::GetBubbles(bool* aBubbles)
         444                 : {
         445               0 :   *aBubbles = !(mEvent->flags & NS_EVENT_FLAG_CANT_BUBBLE);
         446               0 :   return NS_OK;
         447                 : }
         448                 :
         449                 : NS_IMETHODIMP
         450               0 : nsDOMEvent::GetCancelable(bool* aCancelable)
         451                 : {
         452               0 :   *aCancelable = !(mEvent->flags & NS_EVENT_FLAG_CANT_CANCEL);
         453               0 :   return NS_OK;
         454                 : }
         455                 :
         456                 : NS_IMETHODIMP
         457               0 : nsDOMEvent::GetTimeStamp(PRUint64* aTimeStamp)
         458                 : {
         459               0 :   *aTimeStamp = mEvent->time;
         460               0 :   return NS_OK;
         461                 : }
         462                 :
         463                 : NS_IMETHODIMP
         464              10 : nsDOMEvent::StopPropagation()
         465                 : {
         466              10 :   mEvent->flags |= NS_EVENT_FLAG_STOP_DISPATCH;
         467              10 :   return NS_OK;
         468                 : }
         469                 :
         470                 : NS_IMETHODIMP
         471               0 : nsDOMEvent::StopImmediatePropagation()
         472                 : {
         473                 :   mEvent->flags |=
         474               0 :     (NS_EVENT_FLAG_STOP_DISPATCH_IMMEDIATELY | NS_EVENT_FLAG_STOP_DISPATCH);
         475               0 :   return NS_OK;
         476                 : }
         477                 :
         478               0 : static nsIDocument* GetDocumentForReport(nsEvent* aEvent)
         479                 : {
         480               0 :   nsCOMPtr<nsINode> node = do_QueryInterface(aEvent->currentTarget);
         481               0 :   if (node)
         482               0 :     return node->OwnerDoc();
         483                 :
         484               0 :   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aEvent->currentTarget);
         485               0 :   if (!window)
         486               0 :     return nsnull;
         487                 :
         488               0 :   nsCOMPtr<nsIDocument> doc(do_QueryInterface(window->GetExtantDocument()));
         489               0 :   return doc;
         490                 : }
         491                 :
         492                 : static void
         493               0 : ReportUseOfDeprecatedMethod(nsEvent* aEvent, nsIDOMEvent* aDOMEvent,
         494                 :                             const char* aWarning)
         495                 : {
         496               0 :   nsCOMPtr<nsIDocument> doc(GetDocumentForReport(aEvent));
         497                 :
         498               0 :   nsAutoString type;
         499               0 :   aDOMEvent->GetType(type);
         500               0 :   const PRUnichar *strings[] = { type.get() };
         501                 :   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
         502                 :                                   "DOM Events", doc,
         503                 :                                   nsContentUtils::eDOM_PROPERTIES,
         504                 :                                   aWarning,
         505               0 :                                   strings, ArrayLength(strings));
         506               0 : }
         507                 :
         508                 : NS_IMETHODIMP
         509               0 : nsDOMEvent::PreventBubble()
         510                 : {
         511               0 :   ReportUseOfDeprecatedMethod(mEvent, this, "UseOfPreventBubbleWarning");
         512               0 :   return NS_OK;
         513                 : }
         514                 :
         515                 : NS_IMETHODIMP
         516               0 : nsDOMEvent::PreventCapture()
         517                 : {
         518               0 :   ReportUseOfDeprecatedMethod(mEvent, this, "UseOfPreventCaptureWarning");
         519               0 :   return NS_OK;
         520                 : }
         521                 :
         522                 : NS_IMETHODIMP
         523           15343 : nsDOMEvent::GetIsTrusted(bool *aIsTrusted)
         524                 : {
         525           15343 :   *aIsTrusted = NS_IS_TRUSTED_EVENT(mEvent);
         526                 :
         527           15343 :   return NS_OK;
         528                 : }
         529                 :
         530                 : NS_IMETHODIMP
         531              32 : nsDOMEvent::PreventDefault()
         532                 : {
         533              32 :   if (!(mEvent->flags & NS_EVENT_FLAG_CANT_CANCEL)) {
         534              32 :     mEvent->flags |= NS_EVENT_FLAG_NO_DEFAULT;
         535                 :
         536                 :     // Need to set an extra flag for drag events.
         537              32 :     if (mEvent->eventStructType == NS_DRAG_EVENT &&
         538                 :         NS_IS_TRUSTED_EVENT(mEvent)) {
         539               0 :       nsCOMPtr<nsINode> node = do_QueryInterface(mEvent->currentTarget);
         540               0 :       if (!node) {
         541               0 :         nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(mEvent->currentTarget);
         542               0 :         if (win) {
         543               0 :           node = do_QueryInterface(win->GetExtantDocument());
         544                 :         }
         545                 :       }
         546               0 :       if (node && !nsContentUtils::IsChromeDoc(node->OwnerDoc())) {
         547               0 :         mEvent->flags |= NS_EVENT_FLAG_NO_DEFAULT_CALLED_IN_CONTENT;
         548                 :       }
         549                 :     }
         550                 :   }
         551                 :
         552              32 :   return NS_OK;
         553                 : }
         554                 :
         555                 : nsresult
         556           16367 : nsDOMEvent::SetEventType(const nsAString& aEventTypeArg)
         557                 : {
         558                 :   mEvent->userType =
         559                 :     nsContentUtils::GetEventIdAndAtom(aEventTypeArg, mEvent->eventStructType,
         560           16367 :                                       &(mEvent->message));
         561           16367 :   return NS_OK;
         562                 : }
         563                 :
         564                 : NS_IMETHODIMP
         565           16367 : nsDOMEvent::InitEvent(const nsAString& aEventTypeArg, bool aCanBubbleArg, bool aCancelableArg)
         566                 : {
         567                 :   // Make sure this event isn't already being dispatched.
         568           16367 :   NS_ENSURE_TRUE(!NS_IS_EVENT_IN_DISPATCH(mEvent), NS_ERROR_INVALID_ARG);
         569                 :
         570           16367 :   if (NS_IS_TRUSTED_EVENT(mEvent)) {
         571                 :     // Ensure the caller is permitted to dispatch trusted DOM events.
         572                 :
         573            2263 :     bool enabled = false;
         574            2263 :     nsContentUtils::GetSecurityManager()->
         575            2263 :       IsCapabilityEnabled("UniversalXPConnect", &enabled);
         576                 :
         577            2263 :     if (!enabled) {
         578               0 :       SetTrusted(false);
         579                 :     }
         580                 :   }
         581                 :
         582           16367 :   NS_ENSURE_SUCCESS(SetEventType(aEventTypeArg), NS_ERROR_FAILURE);
         583                 :
         584           16367 :   if (aCanBubbleArg) {
         585            2118 :     mEvent->flags &= ~NS_EVENT_FLAG_CANT_BUBBLE;
         586                 :   } else {
         587           14249 :     mEvent->flags |= NS_EVENT_FLAG_CANT_BUBBLE;
         588                 :   }
         589                 :
         590           16367 :   if (aCancelableArg) {
         591            2108 :     mEvent->flags &= ~NS_EVENT_FLAG_CANT_CANCEL;
         592                 :   } else {
         593           14259 :     mEvent->flags |= NS_EVENT_FLAG_CANT_CANCEL;
         594                 :   }
         595                 :
         596                 :   // Clearing the old targets, so that the event is targeted correctly when
         597                 :   // re-dispatching it.
         598           16367 :   mEvent->target = nsnull;
         599           16367 :   mEvent->originalTarget = nsnull;
         600           16367 :   mCachedType = aEventTypeArg;
         601           16367 :   return NS_OK;
         602                 : }
         603                 :
         604              44 : NS_METHOD nsDOMEvent::DuplicatePrivateData()
         605                 : {
         606                 :   // FIXME! Simplify this method and make it somehow easily extendable,
         607                 :   //        Bug 329127
         608                 :
         609              44 :   NS_ASSERTION(mEvent, "No nsEvent for nsDOMEvent duplication!");
         610              44 :   if (mEventIsInternal) {
         611               0 :     return NS_OK;
         612                 :   }
         613                 :
         614              44 :   nsEvent* newEvent = nsnull;
         615              44 :   PRUint32 msg = mEvent->message;
         616              44 :   bool isInputEvent = false;
         617                 :
         618              44 :   switch (mEvent->eventStructType) {
         619                 :     case NS_EVENT:
         620                 :     {
         621               0 :       newEvent = new nsEvent(false, msg);
         622               0 :       break;
         623                 :     }
         624                 :     case NS_GUI_EVENT:
         625                 :     {
         626                 :       // Not copying widget, it is a weak reference.
         627               0 :       newEvent = new nsGUIEvent(false, msg, nsnull);
         628               0 :       break;
         629                 :     }
         630                 :     case NS_SIZE_EVENT:
         631                 :     {
         632               0 :       nsSizeEvent* sizeEvent = new nsSizeEvent(false, msg, nsnull);
         633               0 :       NS_ENSURE_TRUE(sizeEvent, NS_ERROR_OUT_OF_MEMORY);
         634               0 :       sizeEvent->mWinWidth = static_cast<nsSizeEvent*>(mEvent)->mWinWidth;
         635               0 :       sizeEvent->mWinHeight = static_cast<nsSizeEvent*>(mEvent)->mWinHeight;
         636               0 :       newEvent = sizeEvent;
         637               0 :       break;
         638                 :     }
         639                 :     case NS_SIZEMODE_EVENT:
         640                 :     {
         641               0 :       newEvent = new nsSizeModeEvent(false, msg, nsnull);
         642               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         643                 :       static_cast<nsSizeModeEvent*>(newEvent)->mSizeMode =
         644               0 :         static_cast<nsSizeModeEvent*>(mEvent)->mSizeMode;
         645               0 :       break;
         646                 :     }
         647                 :     case NS_ZLEVEL_EVENT:
         648                 :     {
         649               0 :       nsZLevelEvent* zLevelEvent = new nsZLevelEvent(false, msg, nsnull);
         650               0 :       NS_ENSURE_TRUE(zLevelEvent, NS_ERROR_OUT_OF_MEMORY);
         651               0 :       nsZLevelEvent* oldZLevelEvent = static_cast<nsZLevelEvent*>(mEvent);
         652               0 :       zLevelEvent->mPlacement = oldZLevelEvent->mPlacement;
         653               0 :       zLevelEvent->mImmediate = oldZLevelEvent->mImmediate;
         654               0 :       zLevelEvent->mAdjusted = oldZLevelEvent->mAdjusted;
         655               0 :       newEvent = zLevelEvent;
         656               0 :       break;
         657                 :     }
         658                 :     case NS_SCROLLBAR_EVENT:
         659                 :     {
         660               0 :       newEvent = new nsScrollbarEvent(false, msg, nsnull);
         661               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         662                 :       static_cast<nsScrollbarEvent*>(newEvent)->position =
         663               0 :         static_cast<nsScrollbarEvent*>(mEvent)->position;
         664               0 :       break;
         665                 :     }
         666                 :     case NS_INPUT_EVENT:
         667                 :     {
         668               0 :       newEvent = new nsInputEvent(false, msg, nsnull);
         669               0 :       isInputEvent = true;
         670               0 :       break;
         671                 :     }
         672                 :     case NS_KEY_EVENT:
         673                 :     {
         674               0 :       nsKeyEvent* keyEvent = new nsKeyEvent(false, msg, nsnull);
         675               0 :       NS_ENSURE_TRUE(keyEvent, NS_ERROR_OUT_OF_MEMORY);
         676               0 :       nsKeyEvent* oldKeyEvent = static_cast<nsKeyEvent*>(mEvent);
         677               0 :       isInputEvent = true;
         678               0 :       keyEvent->keyCode = oldKeyEvent->keyCode;
         679               0 :       keyEvent->charCode = oldKeyEvent->charCode;
         680               0 :       keyEvent->isChar = oldKeyEvent->isChar;
         681               0 :       newEvent = keyEvent;
         682               0 :       break;
         683                 :     }
         684                 :     case NS_MOUSE_EVENT:
         685                 :     {
         686               0 :       nsMouseEvent* oldMouseEvent = static_cast<nsMouseEvent*>(mEvent);
         687                 :       nsMouseEvent* mouseEvent =
         688               0 :         new nsMouseEvent(false, msg, nsnull, oldMouseEvent->reason);
         689               0 :       NS_ENSURE_TRUE(mouseEvent, NS_ERROR_OUT_OF_MEMORY);
         690               0 :       isInputEvent = true;
         691               0 :       mouseEvent->clickCount = oldMouseEvent->clickCount;
         692               0 :       mouseEvent->acceptActivation = oldMouseEvent->acceptActivation;
         693               0 :       mouseEvent->context = oldMouseEvent->context;
         694               0 :       mouseEvent->relatedTarget = oldMouseEvent->relatedTarget;
         695               0 :       mouseEvent->button = oldMouseEvent->button;
         696               0 :       mouseEvent->pressure = oldMouseEvent->pressure;
         697               0 :       mouseEvent->inputSource = oldMouseEvent->inputSource;
         698               0 :       newEvent = mouseEvent;
         699               0 :       break;
         700                 :     }
         701                 :     case NS_DRAG_EVENT:
         702                 :     {
         703               0 :       nsDragEvent* oldDragEvent = static_cast<nsDragEvent*>(mEvent);
         704                 :       nsDragEvent* dragEvent =
         705               0 :         new nsDragEvent(false, msg, nsnull);
         706               0 :       NS_ENSURE_TRUE(dragEvent, NS_ERROR_OUT_OF_MEMORY);
         707               0 :       isInputEvent = true;
         708               0 :       dragEvent->dataTransfer = oldDragEvent->dataTransfer;
         709               0 :       dragEvent->clickCount = oldDragEvent->clickCount;
         710               0 :       dragEvent->acceptActivation = oldDragEvent->acceptActivation;
         711               0 :       dragEvent->relatedTarget = oldDragEvent->relatedTarget;
         712               0 :       dragEvent->button = oldDragEvent->button;
         713                 :       static_cast<nsMouseEvent*>(dragEvent)->inputSource =
         714               0 :         static_cast<nsMouseEvent*>(oldDragEvent)->inputSource;
         715               0 :       newEvent = dragEvent;
         716               0 :       break;
         717                 :     }
         718                 :     case NS_SCRIPT_ERROR_EVENT:
         719                 :     {
         720               0 :       newEvent = new nsScriptErrorEvent(false, msg);
         721               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         722                 :       static_cast<nsScriptErrorEvent*>(newEvent)->lineNr =
         723               0 :         static_cast<nsScriptErrorEvent*>(mEvent)->lineNr;
         724               0 :       break;
         725                 :     }
         726                 :     case NS_TEXT_EVENT:
         727                 :     {
         728               0 :       newEvent = new nsTextEvent(false, msg, nsnull);
         729               0 :       isInputEvent = true;
         730               0 :       break;
         731                 :     }
         732                 :     case NS_COMPOSITION_EVENT:
         733                 :     {
         734                 :       nsCompositionEvent* compositionEvent =
         735               0 :         new nsCompositionEvent(false, msg, nsnull);
         736                 :       nsCompositionEvent* oldCompositionEvent =
         737               0 :         static_cast<nsCompositionEvent*>(mEvent);
         738               0 :       compositionEvent->data = oldCompositionEvent->data;
         739               0 :       newEvent = compositionEvent;
         740               0 :       break;
         741                 :     }
         742                 :     case NS_MOUSE_SCROLL_EVENT:
         743                 :     {
         744                 :       nsMouseScrollEvent* mouseScrollEvent =
         745               0 :         new nsMouseScrollEvent(false, msg, nsnull);
         746               0 :       NS_ENSURE_TRUE(mouseScrollEvent, NS_ERROR_OUT_OF_MEMORY);
         747               0 :       isInputEvent = true;
         748                 :       nsMouseScrollEvent* oldMouseScrollEvent =
         749               0 :         static_cast<nsMouseScrollEvent*>(mEvent);
         750               0 :       mouseScrollEvent->scrollFlags = oldMouseScrollEvent->scrollFlags;
         751               0 :       mouseScrollEvent->delta = oldMouseScrollEvent->delta;
         752               0 :       mouseScrollEvent->relatedTarget = oldMouseScrollEvent->relatedTarget;
         753               0 :       mouseScrollEvent->button = oldMouseScrollEvent->button;
         754                 :       static_cast<nsMouseEvent_base*>(mouseScrollEvent)->inputSource =
         755               0 :         static_cast<nsMouseEvent_base*>(oldMouseScrollEvent)->inputSource;
         756               0 :       newEvent = mouseScrollEvent;
         757               0 :       break;
         758                 :     }
         759                 :     case NS_SCROLLPORT_EVENT:
         760                 :     {
         761               0 :       newEvent = new nsScrollPortEvent(false, msg, nsnull);
         762               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         763                 :       static_cast<nsScrollPortEvent*>(newEvent)->orient =
         764               0 :         static_cast<nsScrollPortEvent*>(mEvent)->orient;
         765               0 :       break;
         766                 :     }
         767                 :     case NS_SCROLLAREA_EVENT:
         768                 :     {
         769                 :       nsScrollAreaEvent *newScrollAreaEvent =
         770               0 :         new nsScrollAreaEvent(false, msg, nsnull);
         771               0 :       NS_ENSURE_TRUE(newScrollAreaEvent, NS_ERROR_OUT_OF_MEMORY);
         772                 :       newScrollAreaEvent->mArea =
         773               0 :         static_cast<nsScrollAreaEvent *>(mEvent)->mArea;
         774               0 :       newEvent = newScrollAreaEvent;
         775               0 :       break;
         776                 :     }
         777                 :     case NS_MUTATION_EVENT:
         778                 :     {
         779              44 :       nsMutationEvent* mutationEvent = new nsMutationEvent(false, msg);
         780              44 :       NS_ENSURE_TRUE(mutationEvent, NS_ERROR_OUT_OF_MEMORY);
         781                 :       nsMutationEvent* oldMutationEvent =
         782              44 :         static_cast<nsMutationEvent*>(mEvent);
         783              44 :       mutationEvent->mRelatedNode = oldMutationEvent->mRelatedNode;
         784              44 :       mutationEvent->mAttrName = oldMutationEvent->mAttrName;
         785              44 :       mutationEvent->mPrevAttrValue = oldMutationEvent->mPrevAttrValue;
         786              44 :       mutationEvent->mNewAttrValue = oldMutationEvent->mNewAttrValue;
         787              44 :       mutationEvent->mAttrChange = oldMutationEvent->mAttrChange;
         788              44 :       newEvent = mutationEvent;
         789              44 :       break;
         790                 :     }
         791                 : #ifdef ACCESSIBILITY
         792                 :     case NS_ACCESSIBLE_EVENT:
         793                 :     {
         794               0 :       newEvent = new nsAccessibleEvent(false, msg, nsnull);
         795               0 :       isInputEvent = true;
         796               0 :       break;
         797                 :     }
         798                 : #endif
         799                 :     case NS_FORM_EVENT:
         800                 :     {
         801               0 :       newEvent = new nsFormEvent(false, msg);
         802               0 :       break;
         803                 :     }
         804                 :     case NS_FOCUS_EVENT:
         805                 :     {
         806               0 :       nsFocusEvent* newFocusEvent = new nsFocusEvent(false, msg);
         807               0 :       NS_ENSURE_TRUE(newFocusEvent, NS_ERROR_OUT_OF_MEMORY);
         808               0 :       nsFocusEvent* oldFocusEvent = static_cast<nsFocusEvent*>(mEvent);
         809               0 :       newFocusEvent->fromRaise = oldFocusEvent->fromRaise;
         810               0 :       newFocusEvent->isRefocus = oldFocusEvent->isRefocus;
         811               0 :       newEvent = newFocusEvent;
         812               0 :       break;
         813                 :     }
         814                 :
         815                 :     case NS_POPUP_EVENT:
         816                 :     {
         817               0 :       newEvent = new nsInputEvent(false, msg, nsnull);
         818               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         819               0 :       isInputEvent = true;
         820               0 :       newEvent->eventStructType = NS_POPUP_EVENT;
         821               0 :       break;
         822                 :     }
         823                 :     case NS_COMMAND_EVENT:
         824                 :     {
         825                 :       newEvent = new nsCommandEvent(false, mEvent->userType,
         826               0 :         static_cast<nsCommandEvent*>(mEvent)->command, nsnull);
         827               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         828               0 :       break;
         829                 :     }
         830                 :     case NS_UI_EVENT:
         831                 :     {
         832                 :       newEvent = new nsUIEvent(false, msg,
         833               0 :                                static_cast<nsUIEvent*>(mEvent)->detail);
         834               0 :       break;
         835                 :     }
         836                 :     case NS_SVG_EVENT:
         837                 :     {
         838               0 :       newEvent = new nsEvent(false, msg);
         839               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         840               0 :       newEvent->eventStructType = NS_SVG_EVENT;
         841               0 :       break;
         842                 :     }
         843                 :     case NS_SVGZOOM_EVENT:
         844                 :     {
         845               0 :       newEvent = new nsGUIEvent(false, msg, nsnull);
         846               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         847               0 :       newEvent->eventStructType = NS_SVGZOOM_EVENT;
         848               0 :       break;
         849                 :     }
         850                 :     case NS_SMIL_TIME_EVENT:
         851                 :     {
         852               0 :       newEvent = new nsUIEvent(false, msg, 0);
         853               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         854               0 :       newEvent->eventStructType = NS_SMIL_TIME_EVENT;
         855               0 :       break;
         856                 :     }
         857                 :     case NS_SIMPLE_GESTURE_EVENT:
         858                 :     {
         859               0 :       nsSimpleGestureEvent* oldSimpleGestureEvent = static_cast<nsSimpleGestureEvent*>(mEvent);
         860                 :       nsSimpleGestureEvent* simpleGestureEvent =
         861               0 :         new nsSimpleGestureEvent(false, msg, nsnull, 0, 0.0);
         862               0 :       NS_ENSURE_TRUE(simpleGestureEvent, NS_ERROR_OUT_OF_MEMORY);
         863               0 :       isInputEvent = true;
         864               0 :       simpleGestureEvent->direction = oldSimpleGestureEvent->direction;
         865               0 :       simpleGestureEvent->delta = oldSimpleGestureEvent->delta;
         866               0 :       newEvent = simpleGestureEvent;
         867               0 :       break;
         868                 :     }
         869                 :     case NS_TRANSITION_EVENT:
         870                 :     {
         871                 :       nsTransitionEvent* oldTransitionEvent =
         872               0 :         static_cast<nsTransitionEvent*>(mEvent);
         873                 :       newEvent = new nsTransitionEvent(false, msg,
         874                 :                                        oldTransitionEvent->propertyName,
         875               0 :                                        oldTransitionEvent->elapsedTime);
         876               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         877               0 :       break;
         878                 :     }
         879                 :     case NS_ANIMATION_EVENT:
         880                 :     {
         881                 :       nsAnimationEvent* oldAnimationEvent =
         882               0 :         static_cast<nsAnimationEvent*>(mEvent);
         883                 :       newEvent = new nsAnimationEvent(false, msg,
         884                 :                                       oldAnimationEvent->animationName,
         885               0 :                                       oldAnimationEvent->elapsedTime);
         886               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         887               0 :       break;
         888                 :     }
         889                 :     case NS_MOZTOUCH_EVENT:
         890                 :     {
         891                 :       newEvent = new nsMozTouchEvent(false, msg, nsnull,
         892               0 :                                      static_cast<nsMozTouchEvent*>(mEvent)->streamId);
         893               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         894               0 :       isInputEvent = true;
         895               0 :       break;
         896                 :     }
         897                 :     case NS_TOUCH_EVENT:
         898                 :     {
         899               0 :       newEvent = new nsTouchEvent(false, msg, nsnull);
         900               0 :       NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         901               0 :       isInputEvent = true;
         902               0 :       break;
         903                 :     }
         904                 :     default:
         905                 :     {
         906               0 :       NS_WARNING("Unknown event type!!!");
         907               0 :       return NS_ERROR_FAILURE;
         908                 :     }
         909                 :   }
         910                 :
         911              44 :   NS_ENSURE_TRUE(newEvent, NS_ERROR_OUT_OF_MEMORY);
         912                 :
         913              44 :   if (isInputEvent) {
         914               0 :     nsInputEvent* oldInputEvent = static_cast<nsInputEvent*>(mEvent);
         915               0 :     nsInputEvent* newInputEvent = static_cast<nsInputEvent*>(newEvent);
         916               0 :     newInputEvent->isShift = oldInputEvent->isShift;
         917               0 :     newInputEvent->isControl = oldInputEvent->isControl;
         918               0 :     newInputEvent->isAlt = oldInputEvent->isAlt;
         919               0 :     newInputEvent->isMeta = oldInputEvent->isMeta;
         920                 :   }
         921                 :
         922              44 :   newEvent->target                 = mEvent->target;
         923              44 :   newEvent->currentTarget          = mEvent->currentTarget;
         924              44 :   newEvent->originalTarget         = mEvent->originalTarget;
         925              44 :   newEvent->flags                  = mEvent->flags;
         926              44 :   newEvent->time                   = mEvent->time;
         927              44 :   newEvent->refPoint               = mEvent->refPoint;
         928              44 :   newEvent->userType               = mEvent->userType;
         929                 :
         930              44 :   mEvent = newEvent;
         931              44 :   mPresContext = nsnull;
         932              44 :   mEventIsInternal = true;
         933              44 :   mPrivateDataDuplicated = true;
         934                 :
         935              44 :   return NS_OK;
         936                 : }
         937                 :
         938            6401 : NS_METHOD nsDOMEvent::SetTarget(nsIDOMEventTarget* aTarget)
         939                 : {
         940                 : #ifdef DEBUG
         941                 :   {
         942           12802 :     nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(aTarget);
         943                 :
         944            6401 :     NS_ASSERTION(!win || !win->IsInnerWindow(),
         945                 :                  "Uh, inner window set as event target!");
         946                 :   }
         947                 : #endif
         948                 :
         949            6401 :   mEvent->target = do_QueryInterface(aTarget);
         950            6401 :   return NS_OK;
         951                 : }
         952                 :
         953                 : NS_IMETHODIMP_(bool)
         954               0 : nsDOMEvent::IsDispatchStopped()
         955                 : {
         956               0 :   return !!(mEvent->flags & NS_EVENT_FLAG_STOP_DISPATCH);
         957                 : }
         958                 :
         959                 : NS_IMETHODIMP_(nsEvent*)
         960           34893 : nsDOMEvent::GetInternalNSEvent()
         961                 : {
         962           34893 :   return mEvent;
         963                 : }
         964                 :
         965                 : // return true if eventName is contained within events, delimited by
         966                 : // spaces
         967                 : static bool
         968               0 : PopupAllowedForEvent(const char *eventName)
         969                 : {
         970               0 :   if (!sPopupAllowedEvents) {
         971               0 :     nsDOMEvent::PopupAllowedEventsChanged();
         972                 :
         973               0 :     if (!sPopupAllowedEvents) {
         974               0 :       return false;
         975                 :     }
         976                 :   }
         977                 :
         978               0 :   nsDependentCString events(sPopupAllowedEvents);
         979                 :
         980               0 :   nsAFlatCString::const_iterator start, end;
         981               0 :   nsAFlatCString::const_iterator startiter(events.BeginReading(start));
         982               0 :   events.EndReading(end);
         983                 :
         984               0 :   while (startiter != end) {
         985               0 :     nsAFlatCString::const_iterator enditer(end);
         986                 :
         987               0 :     if (!FindInReadable(nsDependentCString(eventName), startiter, enditer))
         988               0 :       return false;
         989                 :
         990                 :     // the match is surrounded by spaces, or at a string boundary
         991               0 :     if ((startiter == start || *--startiter == ' ') &&
         992               0 :         (enditer == end || *enditer == ' ')) {
         993               0 :       return true;
         994                 :     }
         995                 :
         996                 :     // Move on and see if there are other matches. (The delimitation
         997                 :     // requirement makes it pointless to begin the next search before
         998                 :     // the end of the invalid match just found.)
         999               0 :     startiter = enditer;
        1000                 :   }
        1001                 :
        1002               0 :   return false;
        1003                 : }
        1004                 :
        1005                 : // static
        1006                 : PopupControlState
        1007            8232 : nsDOMEvent::GetEventPopupControlState(nsEvent *aEvent)
        1008                 : {
        1009                 :   // generally if an event handler is running, new windows are disallowed.
        1010                 :   // check for exceptions:
        1011            8232 :   PopupControlState abuse = openAbused;
        1012                 :
        1013            8232 :   switch(aEvent->eventStructType) {
        1014                 :   case NS_EVENT :
        1015                 :     // For these following events only allow popups if they're
        1016                 :     // triggered while handling user input. See
        1017                 :     // nsPresShell::HandleEventInternal() for details.
        1018            8226 :     if (nsEventStateManager::IsHandlingUserInput()) {
        1019               0 :       switch(aEvent->message) {
        1020                 :       case NS_FORM_SELECTED :
        1021               0 :         if (::PopupAllowedForEvent("select"))
        1022               0 :           abuse = openControlled;
        1023               0 :         break;
        1024                 :       case NS_FORM_CHANGE :
        1025               0 :         if (::PopupAllowedForEvent("change"))
        1026               0 :           abuse = openControlled;
        1027               0 :         break;
        1028                 :       }
        1029                 :     }
        1030            8226 :     break;
        1031                 :   case NS_GUI_EVENT :
        1032                 :     // For this following event only allow popups if it's triggered
        1033                 :     // while handling user input. See
        1034                 :     // nsPresShell::HandleEventInternal() for details.
        1035               0 :     if (nsEventStateManager::IsHandlingUserInput()) {
        1036               0 :       switch(aEvent->message) {
        1037                 :       case NS_FORM_INPUT :
        1038               0 :         if (::PopupAllowedForEvent("input"))
        1039               0 :           abuse = openControlled;
        1040               0 :         break;
        1041                 :       }
        1042                 :     }
        1043               0 :     break;
        1044                 :   case NS_INPUT_EVENT :
        1045                 :     // For this following event only allow popups if it's triggered
        1046                 :     // while handling user input. See
        1047                 :     // nsPresShell::HandleEventInternal() for details.
        1048               0 :     if (nsEventStateManager::IsHandlingUserInput()) {
        1049               0 :       switch(aEvent->message) {
        1050                 :       case NS_FORM_CHANGE :
        1051               0 :         if (::PopupAllowedForEvent("change"))
        1052               0 :           abuse = openControlled;
        1053               0 :         break;
        1054                 :       case NS_XUL_COMMAND:
        1055               0 :         abuse = openControlled;
        1056               0 :         break;
        1057                 :       }
        1058                 :     }
        1059               0 :     break;
        1060                 :   case NS_KEY_EVENT :
        1061               0 :     if (NS_IS_TRUSTED_EVENT(aEvent)) {
        1062               0 :       PRUint32 key = static_cast<nsKeyEvent *>(aEvent)->keyCode;
        1063               0 :       switch(aEvent->message) {
        1064                 :       case NS_KEY_PRESS :
        1065                 :         // return key on focused button. see note at NS_MOUSE_CLICK.
        1066               0 :         if (key == nsIDOMKeyEvent::DOM_VK_RETURN)
        1067               0 :           abuse = openAllowed;
        1068               0 :         else if (::PopupAllowedForEvent("keypress"))
        1069               0 :           abuse = openControlled;
        1070               0 :         break;
        1071                 :       case NS_KEY_UP :
        1072                 :         // space key on focused button. see note at NS_MOUSE_CLICK.
        1073               0 :         if (key == nsIDOMKeyEvent::DOM_VK_SPACE)
        1074               0 :           abuse = openAllowed;
        1075               0 :         else if (::PopupAllowedForEvent("keyup"))
        1076               0 :           abuse = openControlled;
        1077               0 :         break;
        1078                 :       case NS_KEY_DOWN :
        1079               0 :         if (::PopupAllowedForEvent("keydown"))
        1080               0 :           abuse = openControlled;
        1081               0 :         break;
        1082                 :       }
        1083                 :     }
        1084               0 :     break;
        1085                 :   case NS_MOUSE_EVENT :
        1086               0 :     if (NS_IS_TRUSTED_EVENT(aEvent) &&
        1087                 :         static_cast<nsMouseEvent*>(aEvent)->button == nsMouseEvent::eLeftButton) {
        1088               0 :       switch(aEvent->message) {
        1089                 :       case NS_MOUSE_BUTTON_UP :
        1090               0 :         if (::PopupAllowedForEvent("mouseup"))
        1091               0 :           abuse = openControlled;
        1092               0 :         break;
        1093                 :       case NS_MOUSE_BUTTON_DOWN :
        1094               0 :         if (::PopupAllowedForEvent("mousedown"))
        1095               0 :           abuse = openControlled;
        1096               0 :         break;
        1097                 :       case NS_MOUSE_CLICK :
        1098                 :         /* Click events get special treatment because of their
        1099                 :            historical status as a more legitimate event handler. If
        1100                 :            click popups are enabled in the prefs, clear the popup
        1101                 :            status completely. */
        1102               0 :         if (::PopupAllowedForEvent("click"))
        1103               0 :           abuse = openAllowed;
        1104               0 :         break;
        1105                 :       case NS_MOUSE_DOUBLECLICK :
        1106               0 :         if (::PopupAllowedForEvent("dblclick"))
        1107               0 :           abuse = openControlled;
        1108               0 :         break;
        1109                 :       }
        1110                 :     }
        1111               0 :     break;
        1112                 :   case NS_SCRIPT_ERROR_EVENT :
        1113               0 :     switch(aEvent->message) {
        1114                 :     case NS_LOAD_ERROR :
        1115                 :       // Any error event will allow popups, if enabled in the pref.
        1116               0 :       if (::PopupAllowedForEvent("error"))
        1117               0 :         abuse = openControlled;
        1118               0 :       break;
        1119                 :     }
        1120               0 :     break;
        1121                 :   case NS_FORM_EVENT :
        1122                 :     // For these following events only allow popups if they're
        1123                 :     // triggered while handling user input. See
        1124                 :     // nsPresShell::HandleEventInternal() for details.
        1125               0 :     if (nsEventStateManager::IsHandlingUserInput()) {
        1126               0 :       switch(aEvent->message) {
        1127                 :       case NS_FORM_SUBMIT :
        1128               0 :         if (::PopupAllowedForEvent("submit"))
        1129               0 :           abuse = openControlled;
        1130               0 :         break;
        1131                 :       case NS_FORM_RESET :
        1132               0 :         if (::PopupAllowedForEvent("reset"))
        1133               0 :           abuse = openControlled;
        1134               0 :         break;
        1135                 :       }
        1136                 :     }
        1137               0 :     break;
        1138                 :   }
        1139                 :
        1140            8232 :   return abuse;
        1141                 : }
        1142                 :
        1143                 : // static
        1144                 : void
        1145               0 : nsDOMEvent::PopupAllowedEventsChanged()
        1146                 : {
        1147               0 :   if (sPopupAllowedEvents) {
        1148               0 :     nsMemory::Free(sPopupAllowedEvents);
        1149                 :   }
        1150                 :
        1151               0 :   nsAdoptingCString str = Preferences::GetCString("dom.popup_allowed_events");
        1152                 :
        1153                 :   // We'll want to do this even if str is empty to avoid looking up
        1154                 :   // this pref all the time if it's not set.
        1155               0 :   sPopupAllowedEvents = ToNewCString(str);
        1156               0 : }
        1157                 :
        1158                 : // static
        1159                 : void
        1160            1403 : nsDOMEvent::Shutdown()
        1161                 : {
        1162            1403 :   if (sPopupAllowedEvents) {
        1163               0 :     nsMemory::Free(sPopupAllowedEvents);
        1164                 :   }
        1165            1403 : }
        1166                 :
        1167                 : nsIntPoint
        1168               0 : nsDOMEvent::GetScreenCoords(nsPresContext* aPresContext,
        1169                 :                             nsEvent* aEvent,
        1170                 :                             nsIntPoint aPoint)
        1171                 : {
        1172               0 :   if (!aEvent ||
        1173                 :        (aEvent->eventStructType != NS_MOUSE_EVENT &&
        1174                 :         aEvent->eventStructType != NS_POPUP_EVENT &&
        1175                 :         aEvent->eventStructType != NS_MOUSE_SCROLL_EVENT &&
        1176                 :         aEvent->eventStructType != NS_MOZTOUCH_EVENT &&
        1177                 :         aEvent->eventStructType != NS_TOUCH_EVENT &&
        1178                 :         aEvent->eventStructType != NS_DRAG_EVENT &&
        1179                 :         aEvent->eventStructType != NS_SIMPLE_GESTURE_EVENT)) {
        1180               0 :     return nsIntPoint(0, 0);
        1181                 :   }
        1182                 :
        1183               0 :   nsGUIEvent* guiEvent = static_cast<nsGUIEvent*>(aEvent);
        1184               0 :   if (!guiEvent->widget) {
        1185               0 :     return aPoint;
        1186                 :   }
        1187                 :
        1188               0 :   nsIntPoint offset = aPoint + guiEvent->widget->WidgetToScreenOffset();
        1189               0 :   nscoord factor = aPresContext->DeviceContext()->UnscaledAppUnitsPerDevPixel();
        1190                 :   return nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(offset.x * factor),
        1191               0 :                     nsPresContext::AppUnitsToIntCSSPixels(offset.y * factor));
        1192                 : }
        1193                 :
        1194                 : //static
        1195                 : nsIntPoint
        1196               0 : nsDOMEvent::GetPageCoords(nsPresContext* aPresContext,
        1197                 :                           nsEvent* aEvent,
        1198                 :                           nsIntPoint aPoint,
        1199                 :                           nsIntPoint aDefaultPoint)
        1200                 : {
        1201                 :   nsIntPoint pagePoint = nsDOMEvent::GetClientCoords(aPresContext,
        1202                 :                                                      aEvent,
        1203                 :                                                      aPoint,
        1204               0 :                                                      aDefaultPoint);
        1205                 :
        1206                 :   // If there is some scrolling, add scroll info to client point.
        1207               0 :   if (aPresContext && aPresContext->GetPresShell()) {
        1208               0 :     nsIPresShell* shell = aPresContext->GetPresShell();
        1209               0 :     nsIScrollableFrame* scrollframe = shell->GetRootScrollFrameAsScrollable();
        1210               0 :     if (scrollframe) {
        1211               0 :       nsPoint pt = scrollframe->GetScrollPosition();
        1212                 :       pagePoint += nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(pt.x),
        1213               0 :                               nsPresContext::AppUnitsToIntCSSPixels(pt.y));
        1214                 :     }
        1215                 :   }
        1216                 :
        1217                 :   return pagePoint;
        1218                 : }
        1219                 :
        1220                 : // static
        1221                 : nsIntPoint
        1222               0 : nsDOMEvent::GetClientCoords(nsPresContext* aPresContext,
        1223                 :                             nsEvent* aEvent,
        1224                 :                             nsIntPoint aPoint,
        1225                 :                             nsIntPoint aDefaultPoint)
        1226                 : {
        1227               0 :   if (!aEvent ||
        1228                 :       (aEvent->eventStructType != NS_MOUSE_EVENT &&
        1229                 :        aEvent->eventStructType != NS_POPUP_EVENT &&
        1230                 :        aEvent->eventStructType != NS_MOUSE_SCROLL_EVENT &&
        1231                 :        aEvent->eventStructType != NS_MOZTOUCH_EVENT &&
        1232                 :        aEvent->eventStructType != NS_TOUCH_EVENT &&
        1233                 :        aEvent->eventStructType != NS_DRAG_EVENT &&
        1234                 :        aEvent->eventStructType != NS_SIMPLE_GESTURE_EVENT) ||
        1235                 :       !aPresContext ||
        1236               0 :       !((nsGUIEvent*)aEvent)->widget) {
        1237               0 :     return aDefaultPoint;
        1238                 :   }
        1239                 :
        1240               0 :   nsPoint pt(0, 0);
        1241               0 :   nsIPresShell* shell = aPresContext->GetPresShell();
        1242               0 :   if (!shell) {
        1243               0 :     return nsIntPoint(0, 0);
        1244                 :   }
        1245               0 :   nsIFrame* rootFrame = shell->GetRootFrame();
        1246               0 :   if (rootFrame)
        1247               0 :     pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, aPoint, rootFrame);
        1248                 :
        1249                 :   return nsIntPoint(nsPresContext::AppUnitsToIntCSSPixels(pt.x),
        1250               0 :                     nsPresContext::AppUnitsToIntCSSPixels(pt.y));
        1251                 : }
        1252                 :
        1253                 : // To be called ONLY by nsDOMEvent::GetType (which has the additional
        1254                 : // logic for handling user-defined events).
        1255                 : // static
        1256               0 : const char* nsDOMEvent::GetEventName(PRUint32 aEventType)
        1257                 : {
        1258               0 :   switch(aEventType) {
        1259                 :   case NS_MOUSE_BUTTON_DOWN:
        1260               0 :     return sEventNames[eDOMEvents_mousedown];
        1261                 :   case NS_MOUSE_BUTTON_UP:
        1262               0 :     return sEventNames[eDOMEvents_mouseup];
        1263                 :   case NS_MOUSE_CLICK:
        1264               0 :     return sEventNames[eDOMEvents_click];
        1265                 :   case NS_MOUSE_DOUBLECLICK:
        1266               0 :     return sEventNames[eDOMEvents_dblclick];
        1267                 :   case NS_MOUSEENTER:
        1268               0 :     return sEventNames[eDOMEvents_mouseenter];
        1269                 :   case NS_MOUSELEAVE:
        1270               0 :     return sEventNames[eDOMEvents_mouseleave];
        1271                 :   case NS_MOUSE_ENTER_SYNTH:
        1272               0 :     return sEventNames[eDOMEvents_mouseover];
        1273                 :   case NS_MOUSE_EXIT_SYNTH:
        1274               0 :     return sEventNames[eDOMEvents_mouseout];
        1275                 :   case NS_MOUSE_MOZHITTEST:
        1276               0 :     return sEventNames[eDOMEvents_MozMouseHittest];
        1277                 :   case NS_MOUSE_MOVE:
        1278               0 :     return sEventNames[eDOMEvents_mousemove];
        1279                 :   case NS_KEY_UP:
        1280               0 :     return sEventNames[eDOMEvents_keyup];
        1281                 :   case NS_KEY_DOWN:
        1282               0 :     return sEventNames[eDOMEvents_keydown];
        1283                 :   case NS_KEY_PRESS:
        1284               0 :     return sEventNames[eDOMEvents_keypress];
        1285                 :   case NS_COMPOSITION_START:
        1286               0 :     return sEventNames[eDOMEvents_compositionstart];
        1287                 :   case NS_COMPOSITION_UPDATE:
        1288               0 :     return sEventNames[eDOMEvents_compositionupdate];
        1289                 :   case NS_COMPOSITION_END:
        1290               0 :     return sEventNames[eDOMEvents_compositionend];
        1291                 :   case NS_FOCUS_CONTENT:
        1292               0 :     return sEventNames[eDOMEvents_focus];
        1293                 :   case NS_BLUR_CONTENT:
        1294               0 :     return sEventNames[eDOMEvents_blur];
        1295                 :   case NS_XUL_CLOSE:
        1296               0 :     return sEventNames[eDOMEvents_close];
        1297                 :   case NS_LOAD:
        1298               0 :     return sEventNames[eDOMEvents_load];
        1299                 :   case NS_POPSTATE:
        1300               0 :     return sEventNames[eDOMEvents_popstate];
        1301                 :   case NS_BEFORE_SCRIPT_EXECUTE:
        1302               0 :     return sEventNames[eDOMEvents_beforescriptexecute];
        1303                 :   case NS_AFTER_SCRIPT_EXECUTE:
        1304               0 :     return sEventNames[eDOMEvents_afterscriptexecute];
        1305                 :   case NS_BEFORE_PAGE_UNLOAD:
        1306               0 :     return sEventNames[eDOMEvents_beforeunload];
        1307                 :   case NS_PAGE_UNLOAD:
        1308               0 :     return sEventNames[eDOMEvents_unload];
        1309                 :   case NS_HASHCHANGE:
        1310               0 :     return sEventNames[eDOMEvents_hashchange];
        1311                 :   case NS_READYSTATECHANGE:
        1312               0 :     return sEventNames[eDOMEvents_readystatechange];
        1313                 :   case NS_IMAGE_ABORT:
        1314               0 :     return sEventNames[eDOMEvents_abort];
        1315                 :   case NS_LOAD_ERROR:
        1316               0 :     return sEventNames[eDOMEvents_error];
        1317                 :   case NS_FORM_SUBMIT:
        1318               0 :     return sEventNames[eDOMEvents_submit];
        1319                 :   case NS_FORM_RESET:
        1320               0 :     return sEventNames[eDOMEvents_reset];
        1321                 :   case NS_FORM_CHANGE:
        1322               0 :     return sEventNames[eDOMEvents_change];
        1323                 :   case NS_FORM_SELECTED:
        1324               0 :     return sEventNames[eDOMEvents_select];
        1325                 :   case NS_FORM_INPUT:
        1326               0 :     return sEventNames[eDOMEvents_input];
        1327                 :   case NS_FORM_INVALID:
        1328               0 :     return sEventNames[eDOMEvents_invalid];
        1329                 :   case NS_RESIZE_EVENT:
        1330               0 :     return sEventNames[eDOMEvents_resize];
        1331                 :   case NS_SCROLL_EVENT:
        1332               0 :     return sEventNames[eDOMEvents_scroll];
        1333                 :   case NS_TEXT_TEXT:
        1334               0 :     return sEventNames[eDOMEvents_text];
        1335                 :   case NS_XUL_POPUP_SHOWING:
        1336               0 :     return sEventNames[eDOMEvents_popupShowing];
        1337                 :   case NS_XUL_POPUP_SHOWN:
        1338               0 :     return sEventNames[eDOMEvents_popupShown];
        1339                 :   case NS_XUL_POPUP_HIDING:
        1340               0 :     return sEventNames[eDOMEvents_popupHiding];
        1341                 :   case NS_XUL_POPUP_HIDDEN:
        1342               0 :     return sEventNames[eDOMEvents_popupHidden];
        1343                 :   case NS_XUL_COMMAND:
        1344               0 :     return sEventNames[eDOMEvents_command];
        1345                 :   case NS_XUL_BROADCAST:
        1346               0 :     return sEventNames[eDOMEvents_broadcast];
        1347                 :   case NS_XUL_COMMAND_UPDATE:
        1348               0 :     return sEventNames[eDOMEvents_commandupdate];
        1349                 :   case NS_DRAGDROP_ENTER:
        1350               0 :     return sEventNames[eDOMEvents_dragenter];
        1351                 :   case NS_DRAGDROP_OVER_SYNTH:
        1352               0 :     return sEventNames[eDOMEvents_dragover];
        1353                 :   case NS_DRAGDROP_EXIT_SYNTH:
        1354               0 :     return sEventNames[eDOMEvents_dragexit];
        1355                 :   case NS_DRAGDROP_DRAGDROP:
        1356               0 :     return sEventNames[eDOMEvents_dragdrop];
        1357                 :   case NS_DRAGDROP_GESTURE:
        1358               0 :     return sEventNames[eDOMEvents_draggesture];
        1359                 :   case NS_DRAGDROP_DRAG:
        1360               0 :     return sEventNames[eDOMEvents_drag];
        1361                 :   case NS_DRAGDROP_END:
        1362               0 :     return sEventNames[eDOMEvents_dragend];
        1363                 :   case NS_DRAGDROP_START:
        1364               0 :     return sEventNames[eDOMEvents_dragstart];
        1365                 :   case NS_DRAGDROP_LEAVE_SYNTH:
        1366               0 :     return sEventNames[eDOMEvents_dragleave];
        1367                 :   case NS_DRAGDROP_DROP:
        1368               0 :     return sEventNames[eDOMEvents_drop];
        1369                 :   case NS_SCROLLPORT_OVERFLOW:
        1370               0 :     return sEventNames[eDOMEvents_overflow];
        1371                 :   case NS_SCROLLPORT_UNDERFLOW:
        1372               0 :     return sEventNames[eDOMEvents_underflow];
        1373                 :   case NS_SCROLLPORT_OVERFLOWCHANGED:
        1374               0 :     return sEventNames[eDOMEvents_overflowchanged];
        1375                 :   case NS_MUTATION_SUBTREEMODIFIED:
        1376               0 :     return sEventNames[eDOMEvents_subtreemodified];
        1377                 :   case NS_MUTATION_NODEINSERTED:
        1378               0 :     return sEventNames[eDOMEvents_nodeinserted];
        1379                 :   case NS_MUTATION_NODEREMOVED:
        1380               0 :     return sEventNames[eDOMEvents_noderemoved];
        1381                 :   case NS_MUTATION_NODEREMOVEDFROMDOCUMENT:
        1382               0 :     return sEventNames[eDOMEvents_noderemovedfromdocument];
        1383                 :   case NS_MUTATION_NODEINSERTEDINTODOCUMENT:
        1384               0 :     return sEventNames[eDOMEvents_nodeinsertedintodocument];
        1385                 :   case NS_MUTATION_ATTRMODIFIED:
        1386               0 :     return sEventNames[eDOMEvents_attrmodified];
        1387                 :   case NS_MUTATION_CHARACTERDATAMODIFIED:
        1388               0 :     return sEventNames[eDOMEvents_characterdatamodified];
        1389                 :   case NS_CONTEXTMENU:
        1390               0 :     return sEventNames[eDOMEvents_contextmenu];
        1391                 :   case NS_UI_ACTIVATE:
        1392               0 :     return sEventNames[eDOMEvents_DOMActivate];
        1393                 :   case NS_UI_FOCUSIN:
        1394               0 :     return sEventNames[eDOMEvents_DOMFocusIn];
        1395                 :   case NS_UI_FOCUSOUT:
        1396               0 :     return sEventNames[eDOMEvents_DOMFocusOut];
        1397                 :   case NS_PAGE_SHOW:
        1398               0 :     return sEventNames[eDOMEvents_pageshow];
        1399                 :   case NS_PAGE_HIDE:
        1400               0 :     return sEventNames[eDOMEvents_pagehide];
        1401                 :   case NS_MOUSE_SCROLL:
        1402               0 :     return sEventNames[eDOMEvents_DOMMouseScroll];
        1403                 :   case NS_MOUSE_PIXEL_SCROLL:
        1404               0 :     return sEventNames[eDOMEvents_MozMousePixelScroll];
        1405                 :   case NS_OFFLINE:
        1406               0 :     return sEventNames[eDOMEvents_offline];
        1407                 :   case NS_ONLINE:
        1408               0 :     return sEventNames[eDOMEvents_online];
        1409                 :   case NS_COPY:
        1410               0 :     return sEventNames[eDOMEvents_copy];
        1411                 :   case NS_CUT:
        1412               0 :     return sEventNames[eDOMEvents_cut];
        1413                 :   case NS_PASTE:
        1414               0 :     return sEventNames[eDOMEvents_paste];
        1415                 :   case NS_OPEN:
        1416               0 :     return sEventNames[eDOMEvents_open];
        1417                 :   case NS_MESSAGE:
        1418               0 :     return sEventNames[eDOMEvents_message];
        1419                 :   case NS_SHOW_EVENT:
        1420               0 :     return sEventNames[eDOMEvents_show];
        1421                 :   case NS_SVG_LOAD:
        1422               0 :     return sEventNames[eDOMEvents_SVGLoad];
        1423                 :   case NS_SVG_UNLOAD:
        1424               0 :     return sEventNames[eDOMEvents_SVGUnload];
        1425                 :   case NS_SVG_ABORT:
        1426               0 :     return sEventNames[eDOMEvents_SVGAbort];
        1427                 :   case NS_SVG_ERROR:
        1428               0 :     return sEventNames[eDOMEvents_SVGError];
        1429                 :   case NS_SVG_RESIZE:
        1430               0 :     return sEventNames[eDOMEvents_SVGResize];
        1431                 :   case NS_SVG_SCROLL:
        1432               0 :     return sEventNames[eDOMEvents_SVGScroll];
        1433                 :   case NS_SVG_ZOOM:
        1434               0 :     return sEventNames[eDOMEvents_SVGZoom];
        1435                 :   case NS_TOUCH_START:
        1436               0 :     return sEventNames[eDOMEvents_touchstart];
        1437                 :   case NS_TOUCH_MOVE:
        1438               0 :     return sEventNames[eDOMEvents_touchmove];
        1439                 :   case NS_TOUCH_END:
        1440               0 :     return sEventNames[eDOMEvents_touchend];
        1441                 :   case NS_TOUCH_ENTER:
        1442               0 :     return sEventNames[eDOMEvents_touchenter];
        1443                 :   case NS_TOUCH_LEAVE:
        1444               0 :     return sEventNames[eDOMEvents_touchleave];
        1445                 :   case NS_TOUCH_CANCEL:
        1446               0 :     return sEventNames[eDOMEvents_touchcancel];
        1447                 :   case NS_SMIL_BEGIN:
        1448               0 :     return sEventNames[eDOMEvents_beginEvent];
        1449                 :   case NS_SMIL_END:
        1450               0 :     return sEventNames[eDOMEvents_endEvent];
        1451                 :   case NS_SMIL_REPEAT:
        1452               0 :     return sEventNames[eDOMEvents_repeatEvent];
        1453                 : #ifdef MOZ_MEDIA
        1454                 :   case NS_LOADSTART:
        1455               0 :     return sEventNames[eDOMEvents_loadstart];
        1456                 :   case NS_PROGRESS:
        1457               0 :     return sEventNames[eDOMEvents_progress];
        1458                 :   case NS_SUSPEND:
        1459               0 :     return sEventNames[eDOMEvents_suspend];
        1460                 :   case NS_EMPTIED:
        1461               0 :     return sEventNames[eDOMEvents_emptied];
        1462                 :   case NS_STALLED:
        1463               0 :     return sEventNames[eDOMEvents_stalled];
        1464                 :   case NS_PLAY:
        1465               0 :     return sEventNames[eDOMEvents_play];
        1466                 :   case NS_PAUSE:
        1467               0 :     return sEventNames[eDOMEvents_pause];
        1468                 :   case NS_LOADEDMETADATA:
        1469               0 :     return sEventNames[eDOMEvents_loadedmetadata];
        1470                 :   case NS_LOADEDDATA:
        1471               0 :     return sEventNames[eDOMEvents_loadeddata];
        1472                 :   case NS_WAITING:
        1473               0 :     return sEventNames[eDOMEvents_waiting];
        1474                 :   case NS_PLAYING:
        1475               0 :     return sEventNames[eDOMEvents_playing];
        1476                 :   case NS_CANPLAY:
        1477               0 :     return sEventNames[eDOMEvents_canplay];
        1478                 :   case NS_CANPLAYTHROUGH:
        1479               0 :     return sEventNames[eDOMEvents_canplaythrough];
        1480                 :   case NS_SEEKING:
        1481               0 :     return sEventNames[eDOMEvents_seeking];
        1482                 :   case NS_SEEKED:
        1483               0 :     return sEventNames[eDOMEvents_seeked];
        1484                 :   case NS_TIMEUPDATE:
        1485               0 :     return sEventNames[eDOMEvents_timeupdate];
        1486                 :   case NS_ENDED:
        1487               0 :     return sEventNames[eDOMEvents_ended];
        1488                 :   case NS_RATECHANGE:
        1489               0 :     return sEventNames[eDOMEvents_ratechange];
        1490                 :   case NS_DURATIONCHANGE:
        1491               0 :     return sEventNames[eDOMEvents_durationchange];
        1492                 :   case NS_VOLUMECHANGE:
        1493               0 :     return sEventNames[eDOMEvents_volumechange];
        1494                 :   case NS_MOZAUDIOAVAILABLE:
        1495               0 :     return sEventNames[eDOMEvents_mozaudioavailable];
        1496                 : #endif
        1497                 :   case NS_AFTERPAINT:
        1498               0 :     return sEventNames[eDOMEvents_afterpaint];
        1499                 :   case NS_BEFORERESIZE_EVENT:
        1500               0 :     return sEventNames[eDOMEvents_beforeresize];
        1501                 :   case NS_SIMPLE_GESTURE_SWIPE:
        1502               0 :     return sEventNames[eDOMEvents_MozSwipeGesture];
        1503                 :   case NS_SIMPLE_GESTURE_MAGNIFY_START:
        1504               0 :     return sEventNames[eDOMEvents_MozMagnifyGestureStart];
        1505                 :   case NS_SIMPLE_GESTURE_MAGNIFY_UPDATE:
        1506               0 :     return sEventNames[eDOMEvents_MozMagnifyGestureUpdate];
        1507                 :   case NS_SIMPLE_GESTURE_MAGNIFY:
        1508               0 :     return sEventNames[eDOMEvents_MozMagnifyGesture];
        1509                 :   case NS_SIMPLE_GESTURE_ROTATE_START:
        1510               0 :     return sEventNames[eDOMEvents_MozRotateGestureStart];
        1511                 :   case NS_SIMPLE_GESTURE_ROTATE_UPDATE:
        1512               0 :     return sEventNames[eDOMEvents_MozRotateGestureUpdate];
        1513                 :   case NS_SIMPLE_GESTURE_ROTATE:
        1514               0 :     return sEventNames[eDOMEvents_MozRotateGesture];
        1515                 :   case NS_SIMPLE_GESTURE_TAP:
        1516               0 :     return sEventNames[eDOMEvents_MozTapGesture];
        1517                 :   case NS_SIMPLE_GESTURE_PRESSTAP:
        1518               0 :     return sEventNames[eDOMEvents_MozPressTapGesture];
        1519                 :   case NS_MOZTOUCH_DOWN:
        1520               0 :     return sEventNames[eDOMEvents_MozTouchDown];
        1521                 :   case NS_MOZTOUCH_MOVE:
        1522               0 :     return sEventNames[eDOMEvents_MozTouchMove];
        1523                 :   case NS_MOZTOUCH_UP:
        1524               0 :     return sEventNames[eDOMEvents_MozTouchUp];
        1525                 :   case NS_SCROLLEDAREACHANGED:
        1526               0 :     return sEventNames[eDOMEvents_MozScrolledAreaChanged];
        1527                 :   case NS_TRANSITION_END:
        1528               0 :     return sEventNames[eDOMEvents_transitionend];
        1529                 :   case NS_ANIMATION_START:
        1530               0 :     return sEventNames[eDOMEvents_animationstart];
        1531                 :   case NS_ANIMATION_END:
        1532               0 :     return sEventNames[eDOMEvents_animationend];
        1533                 :   case NS_ANIMATION_ITERATION:
        1534               0 :     return sEventNames[eDOMEvents_animationiteration];
        1535                 :   case NS_DEVICE_MOTION:
        1536               0 :     return sEventNames[eDOMEvents_devicemotion];
        1537                 :   case NS_DEVICE_ORIENTATION:
        1538               0 :     return sEventNames[eDOMEvents_deviceorientation];
        1539                 :   case NS_FULLSCREENCHANGE:
        1540               0 :     return sEventNames[eDOMEvents_mozfullscreenchange];
        1541                 :   case NS_FULLSCREENERROR:
        1542               0 :     return sEventNames[eDOMEvents_mozfullscreenerror];
        1543                 :   default:
        1544                 :     break;
        1545                 :   }
        1546                 :   // XXXldb We can hit this case for nsEvent objects that we didn't
        1547                 :   // create and that are not user defined events since this function and
        1548                 :   // SetEventType are incomplete.  (But fixing that requires fixing the
        1549                 :   // arrays in nsEventListenerManager too, since the events for which
        1550                 :   // this is a problem generally *are* created by nsDOMEvent.)
        1551               0 :   return nsnull;
        1552                 : }
        1553                 :
        1554                 : NS_IMETHODIMP
        1555               0 : nsDOMEvent::GetPreventDefault(bool* aReturn)
        1556                 : {
        1557               0 :   NS_ENSURE_ARG_POINTER(aReturn);
        1558               0 :   *aReturn = mEvent && (mEvent->flags & NS_EVENT_FLAG_NO_DEFAULT);
        1559               0 :   return NS_OK;
        1560                 : }
        1561                 :
        1562                 : NS_IMETHODIMP
        1563               0 : nsDOMEvent::GetDefaultPrevented(bool* aReturn)
        1564                 : {
        1565               0 :   return GetPreventDefault(aReturn);
        1566                 : }
        1567                 :
        1568                 : void
        1569               0 : nsDOMEvent::Serialize(IPC::Message* aMsg, bool aSerializeInterfaceType)
        1570                 : {
        1571               0 :   if (aSerializeInterfaceType) {
        1572               0 :     IPC::WriteParam(aMsg, NS_LITERAL_STRING("event"));
        1573                 :   }
        1574                 :
        1575               0 :   nsString type;
        1576               0 :   GetType(type);
        1577               0 :   IPC::WriteParam(aMsg, type);
        1578                 :
        1579               0 :   bool bubbles = false;
        1580               0 :   GetBubbles(&bubbles);
        1581               0 :   IPC::WriteParam(aMsg, bubbles);
        1582                 :
        1583               0 :   bool cancelable = false;
        1584               0 :   GetCancelable(&cancelable);
        1585               0 :   IPC::WriteParam(aMsg, cancelable);
        1586                 :
        1587               0 :   bool trusted = false;
        1588               0 :   GetIsTrusted(&trusted);
        1589               0 :   IPC::WriteParam(aMsg, trusted);
        1590                 :
        1591                 :   // No timestamp serialization for now!
        1592               0 : }
        1593                 :
        1594                 : bool
        1595               0 : nsDOMEvent::Deserialize(const IPC::Message* aMsg, void** aIter)
        1596                 : {
        1597               0 :   nsString type;
        1598               0 :   NS_ENSURE_TRUE(IPC::ReadParam(aMsg, aIter, &type), false);
        1599                 :
        1600               0 :   bool bubbles = false;
        1601               0 :   NS_ENSURE_TRUE(IPC::ReadParam(aMsg, aIter, &bubbles), false);
        1602                 :
        1603               0 :   bool cancelable = false;
        1604               0 :   NS_ENSURE_TRUE(IPC::ReadParam(aMsg, aIter, &cancelable), false);
        1605                 :
        1606               0 :   bool trusted = false;
        1607               0 :   NS_ENSURE_TRUE(IPC::ReadParam(aMsg, aIter, &trusted), false);
        1608                 :
        1609               0 :   nsresult rv = InitEvent(type, bubbles, cancelable);
        1610               0 :   NS_ENSURE_SUCCESS(rv, false);
        1611               0 :   SetTrusted(trusted);
        1612                 :
        1613               0 :   return true;
        1614                 : }
        1615                 :
        1616                 :
        1617            9216 : nsresult NS_NewDOMEvent(nsIDOMEvent** aInstancePtrResult,
        1618                 :                         nsPresContext* aPresContext,
        1619                 :                         nsEvent *aEvent)
        1620                 : {
        1621            9216 :   nsDOMEvent* it = new nsDOMEvent(aPresContext, aEvent);
        1622            9216 :   if (nsnull == it) {
        1623               0 :     return NS_ERROR_OUT_OF_MEMORY;
        1624                 :   }
        1625                 :
        1626            9216 :   return CallQueryInterface(it, aInstancePtrResult);
        1627            4392 : }

Generated by: LCOV version 1.7