dom/html/HTMLFormElement.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_HTMLFormElement_h
   8 #define mozilla_dom_HTMLFormElement_h
   9
  10 #include "mozilla/AsyncEventDispatcher.h"
  11 #include "mozilla/Attributes.h"
  12 #include "mozilla/UniquePtr.h"
  13 #include "mozilla/dom/BrowsingContext.h"
  14 #include "mozilla/dom/PopupBlocker.h"
  15 #include "mozilla/dom/RadioGroupManager.h"
  16 #include "nsCOMPtr.h"
  17 #include "nsIFormControl.h"
  18 #include "nsGenericHTMLElement.h"
  19 #include "nsIRadioGroupContainer.h"
  20 #include "nsIWeakReferenceUtils.h"
  21 #include "nsThreadUtils.h"
  22 #include "nsInterfaceHashtable.h"
  23 #include "nsRefPtrHashtable.h"
  24 #include "nsTHashMap.h"
  25 #include "js/friend/DOMProxy.h"  // JS::ExpandoAndGeneration
  26
  27 class nsIMutableArray;
  28 class nsIURI;
  29
  30 namespace mozilla {
  31 class EventChainPostVisitor;
  32 class EventChainPreVisitor;
  33 namespace dom {
  34 class DialogFormSubmission;
  35 class HTMLFormControlsCollection;
  36 class HTMLFormSubmission;
  37 class HTMLImageElement;
  38 class FormData;
  39
  40 class HTMLFormElement final : public nsGenericHTMLElement,
  41                               public nsIRadioGroupContainer,
  42                               RadioGroupManager {
  43   friend class HTMLFormControlsCollection;
  44
  45  public:
  46   NS_IMPL_FROMNODE_HTML_WITH_TAG(HTMLFormElement, form)
  47
  48   explicit HTMLFormElement(
  49       already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
  50
  51   enum { FORM_CONTROL_LIST_HASHTABLE_LENGTH = 8 };
  52
  53   // nsISupports
  54   NS_DECL_ISUPPORTS_INHERITED
  55
  56   int32_t IndexOfContent(nsIContent* aContent);
  57   nsGenericHTMLFormElement* GetDefaultSubmitElement() const;
  58
  59   // nsIRadioGroupContainer
  60   void SetCurrentRadioButton(const nsAString& aName,
  61                              HTMLInputElement* aRadio) override;
  62   HTMLInputElement* GetCurrentRadioButton(const nsAString& aName) override;
  63   NS_IMETHOD GetNextRadioButton(const nsAString& aName, const bool aPrevious,
  64                                 HTMLInputElement* aFocusedRadio,
  65                                 HTMLInputElement** aRadioOut) override;
  66   NS_IMETHOD WalkRadioGroup(const nsAString& aName,
  67                             nsIRadioVisitor* aVisitor) override;
  68   void AddToRadioGroup(const nsAString& aName,
  69                        HTMLInputElement* aRadio) override;
  70   void RemoveFromRadioGroup(const nsAString& aName,
  71                             HTMLInputElement* aRadio) override;
  72   virtual uint32_t GetRequiredRadioCount(const nsAString& aName) const override;
  73   virtual void RadioRequiredWillChange(const nsAString& aName,
  74                                        bool aRequiredAdded) override;
  75   virtual bool GetValueMissingState(const nsAString& aName) const override;
  76   virtual void SetValueMissingState(const nsAString& aName,
  77                                     bool aValue) override;
  78
  79   virtual ElementState IntrinsicState() const override;
  80
  81   // EventTarget
  82   virtual void AsyncEventRunning(AsyncEventDispatcher* aEvent) override;
  83
  84   // nsIContent
  85   virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
  86                               const nsAString& aValue,
  87                               nsIPrincipal* aMaybeScriptedPrincipal,
  88                               nsAttrValue& aResult) override;
  89   void GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
  90   void WillHandleEvent(EventChainPostVisitor& aVisitor) override;
  91   virtual nsresult PostHandleEvent(EventChainPostVisitor& aVisitor) override;
  92
  93   virtual nsresult BindToTree(BindContext&, nsINode& aParent) override;
  94   virtual void UnbindFromTree(bool aNullParent = true) override;
  95   virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
  96                                  const nsAttrValueOrString* aValue,
  97                                  bool aNotify) override;
  98
  99   /**
 100    * Forget all information about the current submission (and the fact that we
 101    * are currently submitting at all).
 102    */
 103   void ForgetCurrentSubmission();
 104
 105   virtual nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 106
 107   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLFormElement,
 108                                            nsGenericHTMLElement)
 109
 110   /**
 111    * Remove an element from this form's list of elements
 112    *
 113    * @param aElement the element to remove
 114    * @param aUpdateValidity If true, updates the form validity.
 115    * @return NS_OK if the element was successfully removed.
 116    */
 117   nsresult RemoveElement(nsGenericHTMLFormElement* aElement,
 118                          bool aUpdateValidity);
 119
 120   /**
 121    * Remove an element from the lookup table maintained by the form.
 122    * We can't fold this method into RemoveElement() because when
 123    * RemoveElement() is called it doesn't know if the element is
 124    * removed because the id attribute has changed, or because the
 125    * name attribute has changed.
 126    *
 127    * @param aElement the element to remove
 128    * @param aName the name or id of the element to remove
 129    * @return NS_OK if the element was successfully removed.
 130    */
 131   nsresult RemoveElementFromTable(nsGenericHTMLFormElement* aElement,
 132                                   const nsAString& aName);
 133
 134   /**
 135    * Add an element to end of this form's list of elements
 136    *
 137    * @param aElement the element to add
 138    * @param aUpdateValidity If true, the form validity will be updated.
 139    * @param aNotify If true, send DocumentObserver notifications as needed.
 140    * @return NS_OK if the element was successfully added
 141    */
 142   nsresult AddElement(nsGenericHTMLFormElement* aElement, bool aUpdateValidity,
 143                       bool aNotify);
 144
 145   /**
 146    * Add an element to the lookup table maintained by the form.
 147    *
 148    * We can't fold this method into AddElement() because when
 149    * AddElement() is called, the form control has no
 150    * attributes.  The name or id attributes of the form control
 151    * are used as a key into the table.
 152    */
 153   nsresult AddElementToTable(nsGenericHTMLFormElement* aChild,
 154                              const nsAString& aName);
 155
 156   /**
 157    * Remove an image element from this form's list of image elements
 158    *
 159    * @param aElement the image element to remove
 160    * @return NS_OK if the element was successfully removed.
 161    */
 162   nsresult RemoveImageElement(HTMLImageElement* aElement);
 163
 164   /**
 165    * Remove an image element from the lookup table maintained by the form.
 166    * We can't fold this method into RemoveImageElement() because when
 167    * RemoveImageElement() is called it doesn't know if the element is
 168    * removed because the id attribute has changed, or because the
 169    * name attribute has changed.
 170    *
 171    * @param aElement the image element to remove
 172    * @param aName the name or id of the element to remove
 173    * @return NS_OK if the element was successfully removed.
 174    */
 175   nsresult RemoveImageElementFromTable(HTMLImageElement* aElement,
 176                                        const nsAString& aName);
 177   /**
 178    * Add an image element to the end of this form's list of image elements
 179    *
 180    * @param aElement the element to add
 181    * @return NS_OK if the element was successfully added
 182    */
 183   nsresult AddImageElement(HTMLImageElement* aElement);
 184
 185   /**
 186    * Add an image element to the lookup table maintained by the form.
 187    *
 188    * We can't fold this method into AddImageElement() because when
 189    * AddImageElement() is called, the image attributes can change.
 190    * The name or id attributes of the image are used as a key into the table.
 191    */
 192   nsresult AddImageElementToTable(HTMLImageElement* aChild,
 193                                   const nsAString& aName);
 194
 195   /**
 196    * Returns true if implicit submission of this form is disabled. For more
 197    * on implicit submission see:
 198    *
 199    * http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#implicit-submission
 200    */
 201   bool ImplicitSubmissionIsDisabled() const;
 202
 203   /**
 204    * Check whether a given nsGenericHTMLFormElement is the last single line
 205    * input control that is not disabled. aElement is expected to not be null.
 206    */
 207   bool IsLastActiveElement(const nsGenericHTMLFormElement* aElement) const;
 208
 209   /**
 210    * Check whether a given nsGenericHTMLFormElement is the default submit
 211    * element.  This is different from just comparing to
 212    * GetDefaultSubmitElement() in certain situations inside an update
 213    * when GetDefaultSubmitElement() might not be up to date. aElement
 214    * is expected to not be null.
 215    */
 216   bool IsDefaultSubmitElement(const nsGenericHTMLFormElement* aElement) const;
 217
 218   /**
 219    * Flag the form to know that a button or image triggered scripted form
 220    * submission. In that case the form will defer the submission until the
 221    * script handler returns and the return value is known.
 222    */
 223   void OnSubmitClickBegin(Element* aOriginatingElement);
 224   void OnSubmitClickEnd();
 225
 226   /**
 227    * This method will update the form validity.
 228    *
 229    * This method has to be called by form elements whenever their validity state
 230    * or status regarding constraint validation changes.
 231    *
 232    * @note This method isn't used for CheckValidity().
 233    * @note If an element becomes barred from constraint validation, it has to be
 234    * considered as valid.
 235    *
 236    * @param aElementValidityState the new validity state of the element
 237    */
 238   void UpdateValidity(bool aElementValidityState);
 239
 240   /**
 241    * This method check the form validity and make invalid form elements send
 242    * invalid event if needed.
 243    *
 244    * @return Whether the form is valid.
 245    *
 246    * @note Do not call this method if novalidate/formnovalidate is used.
 247    * @note This method might disappear with bug 592124, hopefuly.
 248    * @see
 249    * https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#interactively-validate-the-constraints
 250    */
 251   bool CheckValidFormSubmission();
 252
 253   /**
 254    * Contruct the entry list to get their data pumped into the FormData and
 255    * fire a `formdata` event with the entry list in formData attribute.
 256    * <https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#constructing-form-data-set>
 257    *
 258    * @param aFormData the form data object
 259    */
 260   // TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230)
 261   MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult ConstructEntryList(FormData* aFormData);
 262
 263   /**
 264    * Whether the submission of this form has been ever prevented because of
 265    * being invalid.
 266    *
 267    * @return Whether the submission of this form has been prevented because of
 268    * being invalid.
 269    */
 270   bool HasEverTriedInvalidSubmit() const { return mEverTriedInvalidSubmit; }
 271
 272   /**
 273    * Implements form[name]. Returns form controls in this form with the correct
 274    * value of the name attribute.
 275    */
 276   already_AddRefed<nsISupports> FindNamedItem(const nsAString& aName,
 277                                               nsWrapperCache** aCache);
 278
 279   // WebIDL
 280
 281   void GetAcceptCharset(DOMString& aValue) {
 282     GetHTMLAttr(nsGkAtoms::acceptcharset, aValue);
 283   }
 284
 285   void SetAcceptCharset(const nsAString& aValue, ErrorResult& aRv) {
 286     SetHTMLAttr(nsGkAtoms::acceptcharset, aValue, aRv);
 287   }
 288
 289   void GetAction(nsString& aValue);
 290   void SetAction(const nsAString& aValue, ErrorResult& aRv) {
 291     SetHTMLAttr(nsGkAtoms::action, aValue, aRv);
 292   }
 293
 294   void GetAutocomplete(nsAString& aValue);
 295   void SetAutocomplete(const nsAString& aValue, ErrorResult& aRv) {
 296     SetHTMLAttr(nsGkAtoms::autocomplete, aValue, aRv);
 297   }
 298
 299   void GetEnctype(nsAString& aValue);
 300   void SetEnctype(const nsAString& aValue, ErrorResult& aRv) {
 301     SetHTMLAttr(nsGkAtoms::enctype, aValue, aRv);
 302   }
 303
 304   void GetEncoding(nsAString& aValue) { GetEnctype(aValue); }
 305   void SetEncoding(const nsAString& aValue, ErrorResult& aRv) {
 306     SetEnctype(aValue, aRv);
 307   }
 308
 309   void GetMethod(nsAString& aValue);
 310   void SetMethod(const nsAString& aValue, ErrorResult& aRv) {
 311     SetHTMLAttr(nsGkAtoms::method, aValue, aRv);
 312   }
 313
 314   void GetName(DOMString& aValue) { GetHTMLAttr(nsGkAtoms::name, aValue); }
 315
 316   void SetName(const nsAString& aValue, ErrorResult& aRv) {
 317     SetHTMLAttr(nsGkAtoms::name, aValue, aRv);
 318   }
 319
 320   bool NoValidate() const { return GetBoolAttr(nsGkAtoms::novalidate); }
 321
 322   void SetNoValidate(bool aValue, ErrorResult& aRv) {
 323     SetHTMLBoolAttr(nsGkAtoms::novalidate, aValue, aRv);
 324   }
 325
 326   void GetTarget(DOMString& aValue) { GetHTMLAttr(nsGkAtoms::target, aValue); }
 327
 328   void SetTarget(const nsAString& aValue, ErrorResult& aRv) {
 329     SetHTMLAttr(nsGkAtoms::target, aValue, aRv);
 330   }
 331
 332   // it's only out-of-line because the class definition is not available in the
 333   // header
 334   nsIHTMLCollection* Elements();
 335
 336   int32_t Length();
 337
 338   /**
 339    * Check whether submission can proceed for this form then fire submit event.
 340    * This basically implements steps 1-6 (more or less) of
 341    * <https://html.spec.whatwg.org/multipage/forms.html#concept-form-submit>.
 342    * @param aSubmitter If not null, is the "submitter" from that algorithm.
 343    *                   Therefore it must be a valid submit control.
 344    */
 345   MOZ_CAN_RUN_SCRIPT void MaybeSubmit(Element* aSubmitter);
 346   MOZ_CAN_RUN_SCRIPT void MaybeReset(Element* aSubmitter);
 347   void Submit(ErrorResult& aRv);
 348
 349   /**
 350    * Requests to submit the form. Unlike submit(), this method includes
 351    * interactive constraint validation and firing a submit event,
 352    * either of which can cancel submission.
 353    *
 354    * @param aSubmitter The submitter argument can be used to point to a specific
 355    *                   submit button.
 356    * @param aRv        An ErrorResult.
 357    * @see
 358    * https://html.spec.whatwg.org/multipage/forms.html#dom-form-requestsubmit
 359    */
 360   MOZ_CAN_RUN_SCRIPT void RequestSubmit(nsGenericHTMLElement* aSubmitter,
 361                                         ErrorResult& aRv);
 362
 363   MOZ_CAN_RUN_SCRIPT void Reset();
 364
 365   bool CheckValidity() { return CheckFormValidity(nullptr); }
 366
 367   bool ReportValidity() { return CheckValidFormSubmission(); }
 368
 369   Element* IndexedGetter(uint32_t aIndex, bool& aFound);
 370
 371   already_AddRefed<nsISupports> NamedGetter(const nsAString& aName,
 372                                             bool& aFound);
 373
 374   void GetSupportedNames(nsTArray<nsString>& aRetval);
 375
 376   static int32_t CompareFormControlPosition(Element* aElement1,
 377                                             Element* aElement2,
 378                                             const nsIContent* aForm);
 379 #ifdef DEBUG
 380   static void AssertDocumentOrder(
 381       const nsTArray<nsGenericHTMLFormElement*>& aControls, nsIContent* aForm);
 382   static void AssertDocumentOrder(
 383       const nsTArray<RefPtr<nsGenericHTMLFormElement>>& aControls,
 384       nsIContent* aForm);
 385 #endif
 386
 387   JS::ExpandoAndGeneration mExpandoAndGeneration;
 388
 389  protected:
 390   virtual JSObject* WrapNode(JSContext* aCx,
 391                              JS::Handle<JSObject*> aGivenProto) override;
 392
 393   void PostPasswordEvent();
 394   void PostPossibleUsernameEvent();
 395
 396   RefPtr<AsyncEventDispatcher> mFormPasswordEventDispatcher;
 397   RefPtr<AsyncEventDispatcher> mFormPossibleUsernameEventDispatcher;
 398
 399   class RemoveElementRunnable;
 400   friend class RemoveElementRunnable;
 401
 402   class RemoveElementRunnable : public Runnable {
 403    public:
 404     explicit RemoveElementRunnable(HTMLFormElement* aForm)
 405         : Runnable("dom::HTMLFormElement::RemoveElementRunnable"),
 406           mForm(aForm) {}
 407
 408     NS_IMETHOD Run() override {
 409       mForm->HandleDefaultSubmitRemoval();
 410       return NS_OK;
 411     }
 412
 413    private:
 414     RefPtr<HTMLFormElement> mForm;
 415   };
 416
 417   nsresult DoReset();
 418
 419   // Async callback to handle removal of our default submit
 420   void HandleDefaultSubmitRemoval();
 421
 422   //
 423   // Submit Helpers
 424   //
 425   //
 426   /**
 427    * Attempt to submit (submission might be deferred)
 428    *
 429    * @param aPresContext the presentation context
 430    * @param aEvent the DOM event that was passed to us for the submit
 431    */
 432   nsresult DoSubmit(Event* aEvent = nullptr);
 433
 434   /**
 435    * Prepare the submission object (called by DoSubmit)
 436    *
 437    * @param aFormSubmission the submission object
 438    * @param aEvent the DOM event that was passed to us for the submit
 439    */
 440   nsresult BuildSubmission(HTMLFormSubmission** aFormSubmission, Event* aEvent);
 441   /**
 442    * Perform the submission (called by DoSubmit and FlushPendingSubmission)
 443    *
 444    * @param aFormSubmission the submission object
 445    */
 446   nsresult SubmitSubmission(HTMLFormSubmission* aFormSubmission);
 447
 448   /**
 449    * Submit a form[method=dialog]
 450    * @param aFormSubmission the submission object
 451    */
 452   nsresult SubmitDialog(DialogFormSubmission* aFormSubmission);
 453
 454   /**
 455    * Notify any submit observers of the submit.
 456    *
 457    * @param aActionURL the URL being submitted to
 458    * @param aCancelSubmit out param where submit observers can specify that the
 459    *        submit should be cancelled.
 460    */
 461   nsresult NotifySubmitObservers(nsIURI* aActionURL, bool* aCancelSubmit,
 462                                  bool aEarlyNotify);
 463
 464   /**
 465    * If this form submission is secure -> insecure, ask the user if they want
 466    * to continue.
 467    *
 468    * @param aActionURL the URL being submitted to
 469    * @param aCancelSubmit out param: will be true if the user wants to cancel
 470    */
 471   nsresult DoSecureToInsecureSubmitCheck(nsIURI* aActionURL,
 472                                          bool* aCancelSubmit);
 473
 474   /**
 475    * Find form controls in this form with the correct value in the name
 476    * attribute.
 477    */
 478   already_AddRefed<nsISupports> DoResolveName(const nsAString& aName);
 479
 480   /**
 481    * Check the form validity following this algorithm:
 482    * https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#statically-validate-the-constraints
 483    *
 484    * @param aInvalidElements [out] parameter containing the list of unhandled
 485    * invalid controls.
 486    *
 487    * @return Whether the form is currently valid.
 488    */
 489   bool CheckFormValidity(nsTArray<RefPtr<Element>>* aInvalidElements) const;
 490
 491   // Clear the mImageNameLookupTable and mImageElements.
 492   void Clear();
 493
 494   // Insert a element into the past names map.
 495   void AddToPastNamesMap(const nsAString& aName, nsISupports* aChild);
 496
 497   // Remove the given element from the past names map.  The element must be an
 498   // nsGenericHTMLFormElement or HTMLImageElement.
 499   void RemoveElementFromPastNamesMap(Element* aElement);
 500
 501   nsresult AddElementToTableInternal(
 502       nsInterfaceHashtable<nsStringHashKey, nsISupports>& aTable,
 503       nsIContent* aChild, const nsAString& aName);
 504
 505   nsresult RemoveElementFromTableInternal(
 506       nsInterfaceHashtable<nsStringHashKey, nsISupports>& aTable,
 507       nsIContent* aChild, const nsAString& aName);
 508
 509  public:
 510   /**
 511    * Flush a possible pending submission. If there was a scripted submission
 512    * triggered by a button or image, the submission was defered. This method
 513    * forces the pending submission to be submitted. (happens when the handler
 514    * returns false or there is an action/target change in the script)
 515    */
 516   void FlushPendingSubmission();
 517
 518   /**
 519    * Get the full URL to submit to.  Do not submit if the returned URL is null.
 520    *
 521    * @param aActionURL the full, unadulterated URL you'll be submitting to [OUT]
 522    * @param aOriginatingElement the originating element of the form submission
 523    * [IN]
 524    */
 525   nsresult GetActionURL(nsIURI** aActionURL, Element* aOriginatingElement);
 526
 527   // Returns a number for this form that is unique within its owner document.
 528   // This is used by nsContentUtils::GenerateStateKey to identify form controls
 529   // that are inserted into the document by the parser.
 530   int32_t GetFormNumberForStateKey();
 531
 532   /**
 533    * Called when we have been cloned and adopted, and the information of the
 534    * node has been changed.
 535    */
 536   void NodeInfoChanged(Document* aOldDoc) override;
 537
 538  protected:
 539   //
 540   // Data members
 541   //
 542   /** The list of controls (form.elements as well as stuff not in elements) */
 543   RefPtr<HTMLFormControlsCollection> mControls;
 544
 545   /** The pending submission object */
 546   UniquePtr<HTMLFormSubmission> mPendingSubmission;
 547
 548   /** The target browsing context, if any. */
 549   RefPtr<BrowsingContext> mTargetContext;
 550   /** The load identifier for the pending request created for a
 551    * submit, used to be able to block double submits. */
 552   Maybe<uint64_t> mCurrentLoadId;
 553
 554   /** The default submit element -- WEAK */
 555   nsGenericHTMLFormElement* mDefaultSubmitElement;
 556
 557   /** The first submit element in mElements -- WEAK */
 558   nsGenericHTMLFormElement* mFirstSubmitInElements;
 559
 560   /** The first submit element in mNotInElements -- WEAK */
 561   nsGenericHTMLFormElement* mFirstSubmitNotInElements;
 562
 563   // This array holds on to all HTMLImageElement(s).
 564   // This is needed to properly clean up the bi-directional references
 565   // (both weak and strong) between the form and its HTMLImageElements.
 566
 567   nsTArray<HTMLImageElement*> mImageElements;  // Holds WEAK references
 568
 569   // A map from an ID or NAME attribute to the HTMLImageElement(s), this
 570   // hash holds strong references either to the named HTMLImageElement, or
 571   // to a list of named HTMLImageElement(s), in the case where this hash
 572   // holds on to a list of named HTMLImageElement(s) the list has weak
 573   // references to the HTMLImageElement.
 574
 575   nsInterfaceHashtable<nsStringHashKey, nsISupports> mImageNameLookupTable;
 576
 577   // A map from names to elements that were gotten by those names from this
 578   // form in that past.  See "past names map" in the HTML5 specification.
 579
 580   nsInterfaceHashtable<nsStringHashKey, nsISupports> mPastNameLookupTable;
 581
 582   /** Keep track of what the popup state was when the submit was initiated */
 583   PopupBlocker::PopupControlState mSubmitPopupState;
 584
 585   /**
 586    * Number of invalid and candidate for constraint validation elements in the
 587    * form the last time UpdateValidity has been called.
 588    */
 589   int32_t mInvalidElementsCount;
 590
 591   // See GetFormNumberForStateKey.
 592   int32_t mFormNumber;
 593
 594   /** Whether we are currently processing a submit event or not */
 595   bool mGeneratingSubmit;
 596   /** Whether we are currently processing a reset event or not */
 597   bool mGeneratingReset;
 598   /** Whether the submission is to be deferred in case a script triggers it */
 599   bool mDeferSubmission;
 600   /** Whether we notified NS_FORMSUBMIT_SUBJECT listeners already */
 601   bool mNotifiedObservers;
 602   /** If we notified the listeners early, what was the result? */
 603   bool mNotifiedObserversResult;
 604   /**
 605    * Whether the submission of this form has been ever prevented because of
 606    * being invalid.
 607    */
 608   bool mEverTriedInvalidSubmit;
 609   /** Whether we are constructing entry list */
 610   bool mIsConstructingEntryList;
 611   /** Whether we are firing submission event */
 612   bool mIsFiringSubmissionEvents;
 613
 614  private:
 615   bool IsSubmitting() const;
 616
 617   NotNull<const Encoding*> GetSubmitEncoding();
 618
 619   /**
 620    * Fire an event when the form is removed from the DOM tree. This is now only
 621    * used by the password manager.
 622    */
 623   void MaybeFireFormRemoved();
 624
 625   ~HTMLFormElement();
 626 };
 627
 628 }  // namespace dom
 629
 630 }  // namespace mozilla
 631
 632 #endif  // mozilla_dom_HTMLFormElement_h