Propagate inert state to OOPIFs when a modal dialog is active

third_party/WebKit/Source/core/html/HTMLDialogElement.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 63 matching lines @@
 
   if (dialog->IsFocusable()) {
     dialog->focus();
     return;
   }
 
   dialog->GetDocument().ClearFocusedElement();
 }
 
 static void InertSubtreesChanged(Document& document) {
+  // TODO(kenrb): Am I correct in thinking that this will never get called on
+  // and element that is in a frame that is already inert? If not, we

[dmazzoni, 2017/05/18 15:47:06]

I don't see how we can know that. A page can always try to call "open" on a
dialog, right?

I think we need to handle that case.

[kenrb, 2017/05/19 17:46:28]

Done.

+  // need to get the embedding frame's inert value and use that instead of
+  // false.
+  if (document.GetFrame())
+    document.GetFrame()->SetIsInert(false);

[aboxhall, 2017/05/18 04:47:27]

When does SetIsInert(true) get called?

Also, you might want to add a case to
https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/html/dial...
to ensure that frames *outside* the dialog (incl. OOPIFs) are correctly made
inert, while frames *inside* the dialog are *not* made inert.

[kenrb, 2017/05/18 12:21:49]

See LocalFrame::SetIsInert(). I should probably add some comments on that
method, but it works such that if you call it with true then it propagates the
inert flag down through all of its descendant frames, and if you call it with
false then it has each of its descendant frames check for inertness via
Node::IsInert().
I can do that. Unfortunately testing OOPIFs in layout tests is a bit more
complicated, since they have to be in LayoutTests/http/tests/ in order to load
frames in different origins. I'll see if I can get something working for that.

+
   // When a modal dialog opens or closes, nodes all over the accessibility
   // tree can change inertness which means they must be added or removed from
   // the tree. The most foolproof way is to clear the entire tree and rebuild
   // it, though a more clever way is probably possible.
   document.ClearAXObjectCache();
   if (AXObjectCache* cache = document.AxObjectCache())
     cache->ChildrenChanged(&document);
 }
 
 inline HTMLDialogElement::HTMLDialogElement(Document& document)
@@ skipping 72 matching lines @@
                                       "The element is not in a Document.");
     return;
   }
 
   GetDocument().AddToTopLayer(this);
   SetBooleanAttribute(openAttr, true);
 
   // Throw away the AX cache first, so the subsequent steps don't have a chance
   // of queuing up AX events on objects that would be invalidated when the cache
   // is thrown away.
   InertSubtreesChanged(GetDocument());

[dmazzoni, 2017/05/18 15:47:06]

I think more logic is needed here.

Previously IsInert was computed just by checking if there's an
active modal dialog in the current frame, so all this method needed
to do was clear some state.

Now, calling showModal needs to actually trigger making other
frames inert. I don't see where this is done...

 
   ForceLayoutForCentering();
   SetFocusForDialog(this);
 }
 
 void HTMLDialogElement::RemovedFrom(ContainerNode* insertion_point) {
   HTMLElement::RemovedFrom(insertion_point);
   SetNotCentered();
-  // FIXME: We should call inertSubtreesChanged() here.
+  InertSubtreesChanged(GetDocument());
 }
 
 void HTMLDialogElement::SetCentered(LayoutUnit centered_position) {
   DCHECK_EQ(centering_mode_, kNeedsCentering);
   centered_position_ = centered_position;
   centering_mode_ = kCentered;
 }
 
 void HTMLDialogElement::SetNotCentered() {
   centering_mode_ = kNotCentered;
@@ skipping 13 matching lines @@
 void HTMLDialogElement::DefaultEventHandler(Event* event) {
   if (event->type() == EventTypeNames::cancel) {
     CloseDialog();
     event->SetDefaultHandled();
     return;
   }
   HTMLElement::DefaultEventHandler(event);
 }
 
 }  // namespace blink