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