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