layout: Keep track of whether we've deferred the painting of the document due to

a script query.

This will, rather unfortunately, mean that we might repaint two times if we've
deferred a paint, then get an out-of-band reflow. Still seemed better than not
suppressing paints at all.

Fixes #13131

components/layout_thread/lib.rs

@@ -85,7 +85,7 @@ use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheResult, ImageCach
 use profile_traits::mem::{self, Report, ReportKind, ReportsChan};
 use profile_traits::time::{TimerMetadataFrameType, TimerMetadataReflowType};
 use profile_traits::time::{self, TimerMetadata, profile};
-use script::layout_wrapper::ServoLayoutNode;
+use script::layout_wrapper::{ServoLayoutDocument, ServoLayoutNode};
 use script_layout_interface::message::{Msg, NewLayoutThreadInfo, Reflow, ReflowQueryType, ScriptReflow};
 use script_layout_interface::reporter::CSSErrorReporter;
 use script_layout_interface::restyle_damage::{REPAINT, STORE_OVERFLOW, REFLOW_OUT_OF_FLOW, REFLOW};
@@ -629,6 +629,7 @@ impl LayoutThread {
                                                                   reflow_info.goal);
 
         self.perform_post_style_recalc_layout_passes(&reflow_info,
+                                                     None,
                                                      &mut *rw_data,
                                                      &mut layout_context);
 
@@ -901,6 +902,7 @@ impl LayoutThread {
 
     fn compute_abs_pos_and_build_display_list(&mut self,
                                               data: &Reflow,
+                                              document: Option<&ServoLayoutDocument>,
                                               layout_root: &mut Flow,
                                               shared_layout_context: &mut SharedLayoutContext,
                                               rw_data: &mut LayoutThreadData) {
@@ -962,7 +964,18 @@ impl LayoutThread {
                     Some(Arc::new(DisplayList::new(root_stacking_context, display_list_entries)))
             }
 
-            if data.goal == ReflowGoal::ForDisplay {
+            if data.goal != ReflowGoal::ForDisplay {
+                // Defer the paint step until the next ForDisplay.
+                //
+                // We need to tell the document about this so it doesn't
+                // incorrectly suppress reflows. See #13131.
+                document.expect("No document in a non-display reflow?")
+                        .needs_paint_from_layout();
+                return;
+            }
+            if let Some(document) = document {
+                document.will_paint();
+            }
             let display_list = (*rw_data.display_list.as_ref().unwrap()).clone();
 
             if opts::get().dump_display_list {
@@ -1015,7 +1028,6 @@ impl LayoutThread {
                     .send(LayoutToPaintMsg::PaintInit(self.epoch, display_list))
                     .unwrap();
             }
-            }
         });
     }
 
@@ -1205,6 +1217,7 @@ impl LayoutThread {
 
         // Perform post-style recalculation layout passes.
         self.perform_post_style_recalc_layout_passes(&data.reflow_info,
+                                                     Some(&document),
                                                      &mut rw_data,
                                                      &mut shared_layout_context);
 
@@ -1327,7 +1340,7 @@ impl LayoutThread {
                                                                   false,
                                                                   reflow_info.goal);
 
-        self.perform_post_main_layout_passes(&reflow_info, &mut *rw_data, &mut layout_context);
+        self.perform_post_main_layout_passes(&reflow_info, None, &mut *rw_data, &mut layout_context);
         true
     }
 
@@ -1385,6 +1398,7 @@ impl LayoutThread {
         }
 
         self.perform_post_style_recalc_layout_passes(&reflow_info,
+                                                     None,
                                                      &mut *rw_data,
                                                      &mut layout_context);
     }
@@ -1407,12 +1421,14 @@ impl LayoutThread {
             return
         }
         self.perform_post_style_recalc_layout_passes(&reflow_info,
+                                                     None,
                                                      &mut *rw_data,
                                                      &mut layout_context);
     }
 
     fn perform_post_style_recalc_layout_passes(&mut self,
                                                data: &Reflow,
+                                               document: Option<&ServoLayoutDocument>,
                                                rw_data: &mut LayoutThreadData,
                                                layout_context: &mut SharedLayoutContext) {
         if let Some(mut root_flow) = self.root_flow.clone() {
@@ -1487,17 +1503,19 @@ impl LayoutThread {
                                            flow_ref::deref_mut(&mut root_flow) as &mut Flow);
             });
 
-            self.perform_post_main_layout_passes(data, rw_data, layout_context);
+            self.perform_post_main_layout_passes(data, document, rw_data, layout_context);
         }
     }
 
     fn perform_post_main_layout_passes(&mut self,
                                        data: &Reflow,
+                                       document: Option<&ServoLayoutDocument>,
                                        rw_data: &mut LayoutThreadData,
                                        layout_context: &mut SharedLayoutContext) {
         // Build the display list if necessary, and send it to the painter.
         if let Some(mut root_flow) = self.root_flow.clone() {
             self.compute_abs_pos_and_build_display_list(data,
+                                                        document,
                                                         flow_ref::deref_mut(&mut root_flow),
                                                         &mut *layout_context,
                                                         rw_data);

components/script/dom/document.rs

@@ -221,6 +221,9 @@ pub struct Document {
     /// For each element that has had a state or attribute change since the last restyle,
     /// track the original condition of the element.
     modified_elements: DOMRefCell<HashMap<JS<Element>, ElementSnapshot>>,
+    /// This flag will be true if layout suppressed a reflow attempt that was
+    /// needed in order for the page to be painted.
+    needs_paint: Cell<bool>,
     /// http://w3c.github.io/touch-events/#dfn-active-touch-point
     active_touch_points: DOMRefCell<Vec<JS<Touch>>>,
     /// Navigation Timing properties:
@@ -376,6 +379,10 @@ impl Document {
         }
     }
 
+    pub fn needs_paint(&self) -> bool {
+        self.needs_paint.get()
+    }
+
     pub fn needs_reflow(&self) -> bool {
         // FIXME: This should check the dirty bit on the document,
         // not the document element. Needs some layout changes to make
@@ -384,7 +391,8 @@ impl Document {
             Some(root) => {
                 root.upcast::<Node>().is_dirty() ||
                 root.upcast::<Node>().has_dirty_descendants() ||
-                !self.modified_elements.borrow().is_empty()
+                !self.modified_elements.borrow().is_empty() ||
+                self.needs_paint()
             }
             None => false,
         }
@@ -1602,6 +1610,8 @@ pub enum DocumentSource {
 pub trait LayoutDocumentHelpers {
     unsafe fn is_html_document_for_layout(&self) -> bool;
     unsafe fn drain_modified_elements(&self) -> Vec<(LayoutJS<Element>, ElementSnapshot)>;
+    unsafe fn needs_paint_from_layout(&self);
+    unsafe fn will_paint(&self);
 }
 
 #[allow(unsafe_code)]
@@ -1618,6 +1628,16 @@ impl LayoutDocumentHelpers for LayoutJS<Document> {
         let result = elements.drain().map(|(k, v)| (k.to_layout(), v)).collect();
         result
     }
+
+    #[inline]
+    unsafe fn needs_paint_from_layout(&self) {
+        (*self.unsafe_get()).needs_paint.set(true)
+    }
+
+    #[inline]
+    unsafe fn will_paint(&self) {
+        (*self.unsafe_get()).needs_paint.set(false)
+    }
 }
 
 /// https://url.spec.whatwg.org/#network-scheme
@@ -1723,6 +1743,7 @@ impl Document {
             base_element: Default::default(),
             appropriate_template_contents_owner_document: Default::default(),
             modified_elements: DOMRefCell::new(HashMap::new()),
+            needs_paint: Cell::new(false),
             active_touch_points: DOMRefCell::new(Vec::new()),
             dom_loading: Cell::new(Default::default()),
             dom_interactive: Cell::new(Default::default()),

components/script/dom/window.rs

@@ -1200,9 +1200,11 @@ impl Window {
         if !for_display || self.Document().needs_reflow() {
             issued_reflow = self.force_reflow(goal, query_type, reason);
 
-            // If window_size is `None`, we don't reflow, so the document stays dirty.
-            // Otherwise, we shouldn't need a reflow immediately after a reflow.
+            // If window_size is `None`, we don't reflow, so the document stays
+            // dirty. Otherwise, we shouldn't need a reflow immediately after a
+            // reflow, except if we're waiting for a deferred paint.
             assert!(!self.Document().needs_reflow() ||
+                    (!for_display && self.Document().needs_paint()) ||
                     self.window_size.get().is_none() ||
                     self.suppress_reflow.get());
         } else {

components/script/layout_wrapper.rs

@@ -405,6 +405,14 @@ impl<'ld> TDocument for ServoLayoutDocument<'ld> {
         let elements =  unsafe { self.document.drain_modified_elements() };
         elements.into_iter().map(|(el, snapshot)| (ServoLayoutElement::from_layout_js(el), snapshot)).collect()
     }
+
+    fn needs_paint_from_layout(&self) {
+        unsafe { self.document.needs_paint_from_layout(); }
+    }
+
+    fn will_paint(&self) {
+        unsafe { self.document.will_paint(); }
+    }
 }
 
 impl<'ld> ServoLayoutDocument<'ld> {

components/style/dom.rs

@@ -179,6 +179,9 @@ pub trait TDocument : Sized + Copy + Clone {
 
     fn drain_modified_elements(&self) -> Vec<(Self::ConcreteElement,
                                               <Self::ConcreteElement as ElementExt>::Snapshot)>;
+
+    fn needs_paint_from_layout(&self);
+    fn will_paint(&self);
 }
 
 pub trait PresentationalHintsSynthetizer {

ports/geckolib/wrapper.rs

@@ -414,6 +414,8 @@ impl<'ld> TDocument for GeckoDocument<'ld> {
         let elements =  unsafe { self.document.drain_modified_elements() };
         elements.into_iter().map(|(el, snapshot)| (ServoLayoutElement::from_layout_js(el), snapshot)).collect()*/
     }
+    fn will_paint(&self) { unimplemented!() }
+    fn needs_paint_from_layout(&self) { unimplemented!() }
 }
 
 #[derive(Clone, Copy)]