Implement basic structure for dialog light dismiss [1/N]

This CL puts the feature flag in place, adds (flag guarded) closedBy
and requestClose() methods to <dialog>, connects the pointer
events handling to a new dialog light dismiss method, and adds a
basic set of tests. None of the actual functionality is here yet,
this is just a shell. Subsequent CLs will flesh out the behavior.

See spec PR for details:
  whatwg/html#10737

Here's the chromestatus:
  https://chromestatus.com/feature/5097714453577728

Bug: 376516550
Change-Id: I3727ca21476a2a3340fd18597970395d64ef7176
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5985491
Commit-Queue: Mason Freed <masonf@chromium.org>
Reviewed-by: David Baron <dbaron@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1378633}

Author: mfreed7

third_party/blink/renderer/core/dom/document.cc

@@ -8016,6 +8016,17 @@ void Document::SetPopoverPointerdownTarget(const HTMLElement* popover) {
   popover_pointerdown_target_ = popover;
 }
 
+const HTMLDialogElement* Document::DialogPointerdownTarget() const {
+  CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
+  return dialog_pointerdown_target_.Get();
+}
+
+void Document::SetDialogPointerdownTarget(const HTMLDialogElement* dialog) {
+  CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
+  DCHECK(!dialog || dialog->IsOpen());
+  dialog_pointerdown_target_ = dialog;
+}
+
 void Document::exitPointerLock() {
   if (!GetPage())
     return;
@@ -8730,6 +8741,7 @@ void Document::Trace(Visitor* visitor) const {
   visitor->Trace(popover_auto_stack_);
   visitor->Trace(popover_hint_stack_);
   visitor->Trace(popover_pointerdown_target_);
+  visitor->Trace(dialog_pointerdown_target_);
   visitor->Trace(popovers_waiting_to_hide_);
   visitor->Trace(all_open_popovers_);
   visitor->Trace(document_part_root_);

third_party/blink/renderer/core/dom/document.h

@@ -1651,6 +1651,8 @@ class CORE_EXPORT Document : public ContainerNode,
     return popover_pointerdown_target_.Get();
   }
   void SetPopoverPointerdownTarget(const HTMLElement*);
+  const HTMLDialogElement* DialogPointerdownTarget() const;
+  void SetDialogPointerdownTarget(const HTMLDialogElement*);
 
   // https://crbug.com/1453291
   // The DOM Parts API:
@@ -2702,6 +2704,11 @@ class CORE_EXPORT Document : public ContainerNode,
   HeapVector<Member<HTMLElement>> popover_hint_stack_;
   // The popover (if any) that received the most recent pointerdown event.
   Member<const HTMLElement> popover_pointerdown_target_;
+  // The dialog (if any) that received the most recent pointerdown event. This
+  // is distinct from popover_pointerdown_target_ because the same pointer
+  // action could trigger light dismiss on a containing popover and not a
+  // containing dialog, or vice versa.
+  Member<const HTMLDialogElement> dialog_pointerdown_target_;
   // A set of popovers for which hidePopover() has been called, but animations
   // are still running.
   HeapHashSet<Member<HTMLElement>> popovers_waiting_to_hide_;

third_party/blink/renderer/core/html/closewatcher/close_watcher.cc

@@ -207,6 +207,10 @@ bool CloseWatcher::requestClose() {
   if (IsClosed() || dispatching_cancel_ || !DomWindow()) {
     return true;
   }
+  if (!enabled_) {
+    CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
+    return true;
+  }
 
   WatcherStack& stack = *DomWindow()->closewatcher_stack();
   Event& cancel_event =
@@ -231,10 +235,11 @@ bool CloseWatcher::requestClose() {
 }
 
 void CloseWatcher::close() {
-  if (IsClosed()) {
+  if (IsClosed() || !DomWindow() || !DomWindow()->document()->IsActive()) {
     return;
   }
-  if (!DomWindow() || !DomWindow()->document()->IsActive()) {
+  if (!enabled_) {
+    CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
     return;
   }
 

third_party/blink/renderer/core/html/closewatcher/close_watcher.h

@@ -92,6 +92,7 @@ class CloseWatcher final : public EventTarget, public ExecutionContextClient {
   enum class State { kActive, kClosed };
   State state_ = State::kActive;
   bool dispatching_cancel_ = false;
+  bool enabled_ = true;
   Member<AbortSignal::AlgorithmHandle> abort_handle_;
 };
 

third_party/blink/renderer/core/html/html_attribute_names.json5

@@ -50,6 +50,7 @@
     "class",
     "classid",
     "clear",
+    "closedby",
     "code",
     "codebase",
     "codetype",

third_party/blink/renderer/core/html/html_dialog_element.cc

@@ -146,19 +146,19 @@ void HTMLDialogElement::close(const String& return_value,
   }
   base::AutoReset<bool> reset_close(&is_closing_, true);
 
-  if (!ignore_open_attribute && !FastHasAttribute(html_names::kOpenAttr)) {
+  if (!ignore_open_attribute && !IsOpen()) {
     return;
   }
 
   Document& document = GetDocument();
   HTMLDialogElement* old_modal_dialog = document.ActiveModalDialog();
 
   DispatchToggleEvents(/*opening=*/false);
-  if (!ignore_open_attribute && !FastHasAttribute(html_names::kOpenAttr)) {
+  if (!ignore_open_attribute && !IsOpen()) {
     return;
   }
   SetBooleanAttribute(html_names::kOpenAttr, false);
-  bool was_modal = is_modal_;
+  bool was_modal = IsModal();
   SetIsModal(false);
 
   // If this dialog is open as a non-modal dialog and open as a popover at the
@@ -199,6 +199,44 @@ void HTMLDialogElement::close(const String& return_value,
   }
 }
 
+void HTMLDialogElement::requestClose(const String& return_value) {
+  CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
+  // TODO(crbug.com/376516550): Implement this function.
+}
+
+String HTMLDialogElement::closedBy() const {
+  CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
+  // TODO(crbug.com/376516550): This should be "limited to only known values".
+  return "Unimplemented";
+}
+void HTMLDialogElement::setClosedBy(const String& new_value) {
+  CHECK(RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled());
+  // TODO(crbug.com/376516550): This should be "limited to only known values".
+}
+
+// static
+void HTMLDialogElement::HandleDialogLightDismiss(const Event& event,
+                                                 const Node& target_node) {
+  // TODO(crbug.com/376516550): Implement spec behavior:
+  // 1. Assert: event's isTrusted attribute is true.
+  // 2. Let target be event's target.
+  // 3. Let document be target's node document.
+  // 4. If document's light dismissible dialog list is empty, then return.
+  // 5. If event is a PointerEvent and event's type is "pointerdown", then: set
+  //    document's dialog pointerdown target to the result of running topmost
+  //    clicked dialog given target.
+  // 6. If event is a PointerEvent and event's type is " pointerup ", then:
+  //  1. Let clickedDialog be the result of running topmost clicked dialog given
+  //     target.
+  //  2. Let topDialog be document's light dismissible dialog list's last
+  //     element.
+  //  3. Let sameTarget be true if clickedDialog is dialog pointerdown target.
+  //  4. Let clickedTopDialog be true if clickedDialog is topDialog ,
+  //  5. Set document's dialog pointerdown target to null.
+  //  6. If clickedTopDialog is true or sameTarget is false, then return.
+  //  7. Perform request to close the dialog given topDialog.
+}
+
 bool HTMLDialogElement::IsValidBuiltinCommand(HTMLElement& invoker,
                                               CommandEventType command) {
   return HTMLElement::IsValidBuiltinCommand(invoker, command) ||
@@ -223,7 +261,7 @@ bool HTMLDialogElement::HandleCommandInternal(HTMLElement& invoker,
     return false;
   }
 
-  bool open = FastHasAttribute(html_names::kOpenAttr);
+  bool open = IsOpen();
 
   if (command == CommandEventType::kClose) {
     if (open) {
@@ -263,8 +301,8 @@ void HTMLDialogElement::ScheduleCloseEvent() {
 }
 
 void HTMLDialogElement::show(ExceptionState& exception_state) {
-  if (FastHasAttribute(html_names::kOpenAttr)) {
-    if (is_modal_) {
+  if (IsOpen()) {
+    if (IsModal()) {
       exception_state.ThrowDOMException(
           DOMExceptionCode::kInvalidStateError,
           "The dialog is already open as a modal dialog, and therefore "
@@ -278,6 +316,17 @@ void HTMLDialogElement::show(ExceptionState& exception_state) {
   }
   SetBooleanAttribute(html_names::kOpenAttr, true);
 
+  if (RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled()) {
+    // TODO(crbug.com/376516550): Implement spec behavior:
+    //  - Set this's close watcher to the result of establishing a close watcher
+    //    given this's relevant global object, with:
+    //  - cancelAction being to return the result of firing an event named
+    //    cancel at this, with the cancelable attribute initialized to true.
+    //  - closeAction being to close the dialog given this and null.
+    //  - enabled being true if this's closedby attribute state is Any or Close
+    //    Request; otherwise false.
+  }
+
   // The layout must be updated here because setFocusForDialog calls
   // Element::isFocusable, which requires an up-to-date layout.
   GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kJavaScript);
@@ -335,8 +384,8 @@ class DialogCloseWatcherEventListener : public NativeEventListener {
 };
 
 void HTMLDialogElement::showModal(ExceptionState& exception_state) {
-  if (FastHasAttribute(html_names::kOpenAttr)) {
-    if (!is_modal_) {
+  if (IsOpen()) {
+    if (!IsModal()) {
       exception_state.ThrowDOMException(
           DOMExceptionCode::kInvalidStateError,
           "The dialog is already open as a non-modal dialog, and therefore "
@@ -376,9 +425,15 @@ void HTMLDialogElement::showModal(ExceptionState& exception_state) {
 
   document.AddToTopLayer(this);
   SetBooleanAttribute(html_names::kOpenAttr, true);
-
   SetIsModal(true);
 
+  if (RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled()) {
+    // TODO(crbug.com/376516550): Implement spec behavior:
+    // Set this's close watcher to...
+    //  - enabled being true if this's closedby attribute is in the Any, Close
+    //    Request, or Auto state; otherwise false.
+  }
+
   // Refresh the AX cache first, because most of it is changing.
   InertSubtreesChanged(document, old_modal_dialog);
   document.UpdateStyleAndLayout(DocumentUpdateReason::kJavaScript);
@@ -461,7 +516,7 @@ void HTMLDialogElement::SetFocusForDialog() {
 
   if (control->IsFocusable())
     control->Focus();
-  else if (is_modal_) {
+  else if (IsModal()) {
     control->GetDocument().ClearFocusedElement();
   }
 
@@ -500,7 +555,7 @@ bool HTMLDialogElement::DispatchToggleEvents(bool opening, bool asModal) {
     return false;
   }
   if (opening) {
-    if (FastHasAttribute(html_names::kOpenAttr)) {
+    if (IsOpen()) {
       return false;
     }
     if (asModal &&
@@ -552,6 +607,18 @@ void HTMLDialogElement::ParseAttribute(
     close(/*return_value=*/String(), /*ignore_open_attribute=*/true);
   }
 
+  if (RuntimeEnabledFeatures::HTMLDialogLightDismissEnabled() &&
+      params.name == html_names::kClosedbyAttr) {
+    // TODO(crbug.com/376516550): Implement spec behavior:
+    //  3. If element has no open attribute, then return.
+    //  4. If oldValue and value are in the same state, then return.
+    //  5. Assert : element's close watcher is not null.
+    //  6. If value is in the Any state, or Close Request state, or Auto state
+    //     and element's is modal flag is true, then let enabled to true;
+    //     otherwise false.
+    //  7. Set element's close watcher's enabled boolean to enabled.
+  }
+
   HTMLElement::ParseAttribute(params);
 }
 

third_party/blink/renderer/core/html/html_dialog_element.h

@@ -48,17 +48,25 @@ class CORE_EXPORT HTMLDialogElement final : public HTMLElement {
 
   void close(const String& return_value = String(),
              bool ignore_open_attribute = false);
+  void requestClose(const String& return_value = String());
   void show(ExceptionState&);
   void showModal(ExceptionState&);
   void RemovedFrom(ContainerNode&) override;
 
   bool IsModal() const { return is_modal_; }
+  bool IsOpen() const { return FastHasAttribute(html_names::kOpenAttr); }
 
   String returnValue() const { return return_value_; }
   void setReturnValue(const String& return_value) {
     return_value_ = return_value;
   }
 
+  String closedBy() const;
+  void setClosedBy(const String& return_value);
+
+  static void HandleDialogLightDismiss(const Event& event,
+                                       const Node& target_node);
+
   void CloseWatcherFiredCancel(Event*);
   void CloseWatcherFiredClose();
 

third_party/blink/renderer/core/html/html_dialog_element.idl

@@ -30,7 +30,9 @@
 ] interface HTMLDialogElement : HTMLElement {
     [CEReactions, Reflect] attribute boolean open;
     attribute DOMString returnValue;
+    [CEReactions,RuntimeEnabled=HTMLDialogLightDismiss] attribute DOMString closedBy;
     [CEReactions, Measure, RaisesException] void show();
     [CEReactions, Measure, RaisesException] void showModal();
     [CEReactions] void close(optional DOMString returnValue);
+    [CEReactions,RuntimeEnabled=HTMLDialogLightDismiss] void requestClose(optional DOMString returnValue);
 };

third_party/blink/renderer/core/input/pointer_event_manager.cc

@@ -21,6 +21,7 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_frame_view.h"
 #include "third_party/blink/renderer/core/html/canvas/html_canvas_element.h"
+#include "third_party/blink/renderer/core/html/html_dialog_element.h"
 #include "third_party/blink/renderer/core/input/event_handler.h"
 #include "third_party/blink/renderer/core/input/event_handling_util.h"
 #include "third_party/blink/renderer/core/input/mouse_event_manager.h"
@@ -190,6 +191,7 @@ WebInputEventResult PointerEventManager::DispatchPointerEvent(
   if (Node* target_node = target->ToNode()) {
     if (event_type == event_type_names::kPointerdown ||
         event_type == event_type_names::kPointerup) {
+      HTMLDialogElement::HandleDialogLightDismiss(*pointer_event, *target_node);
       HTMLElement::HandlePopoverLightDismiss(*pointer_event, *target_node);
     }
   }

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -2310,6 +2310,11 @@
       name: "HTMLAnchorAttribute",
       status: "experimental",
     },
+    {
+      // TODO(crbug.com/376516550): Enables dialog light dismiss functionality.
+      name: "HTMLDialogLightDismiss",
+      status: "experimental",
+    },
     // The `<embed>` should follow the specification, layout is not forced
     // when the `type` attribute is set to `image`.
     // https://html.spec.whatwg.org/C/#the-embed-element