Add a mechanism to rebuild the hit tester without a full render.

This path just updates the clip scroll tree and hit-tester, without
doing all the extra render work needed for a full frame render. When we
do an async scene swap, we can use this instead of doing a full render
to get the hit-test information in sync with Gecko.

Fixes #2807

webrender/src/frame_builder.rs

@@ -302,6 +302,24 @@ impl FrameBuilder {
         }
     }
 
+    pub fn update_clip_scroll_tree(
+        &mut self,
+        clip_render_context: &mut Option<ClipRenderContext>,
+        clip_scroll_tree: &mut ClipScrollTree,
+        device_pixel_scale: DevicePixelScale,
+        pan: WorldPoint,
+        scene_properties: &SceneProperties,
+    ) -> Option<TransformPalette> {
+        clip_scroll_tree.update_tree(
+            &self.screen_rect.to_i32(),
+            device_pixel_scale,
+            &mut self.clip_store,
+            clip_render_context,
+            pan,
+            scene_properties,
+        )
+    }
+
     pub fn build(
         &mut self,
         resource_cache: &mut ResourceCache,
@@ -335,15 +353,14 @@ impl FrameBuilder {
                 resource_cache,
                 gpu_cache,
             };
-            clip_scroll_tree.update_tree(
-                &self.screen_rect.to_i32(),
-                device_pixel_scale,
-                &mut self.clip_store,
+            self.update_clip_scroll_tree(
                 &mut Some(clip_render_context),
+                clip_scroll_tree,
+                device_pixel_scale,
                 pan,
-                scene_properties,
-            ).expect("Must get a palette since we provided a render context")
-        };
+                scene_properties
+            )
+        }.expect("Must get a palette since we provided a render context");
 
         self.update_scroll_bars(clip_scroll_tree, gpu_cache);
 

webrender/src/render_backend.rs

@@ -359,6 +359,22 @@ impl Document {
         }).unwrap();
     }
 
+    fn rebuild_hit_tester(&mut self) {
+        let accumulated_scale_factor = self.view.accumulated_scale_factor();
+        let pan = self.view.pan.to_f32() / accumulated_scale_factor;
+
+        let frame_builder = self.frame_builder.as_mut().unwrap();
+        let palette = frame_builder.update_clip_scroll_tree(
+            &mut None,
+            &mut self.clip_scroll_tree,
+            accumulated_scale_factor,
+            pan,
+            &self.dynamic_properties,
+        );
+        debug_assert!(!palette.is_some());
+        self.hit_tester = Some(frame_builder.create_hit_tester(&self.clip_scroll_tree));
+    }
+
     fn render(
         &mut self,
         resource_cache: &mut ResourceCache,
@@ -448,6 +464,7 @@ impl Document {
 struct DocumentOps {
     scroll: bool,
     build: bool,
+    rebuild_hit_tester: bool,
     render: bool,
     composite: bool,
 }
@@ -457,6 +474,7 @@ impl DocumentOps {
         DocumentOps {
             scroll: false,
             build: false,
+            rebuild_hit_tester: false,
             render: false,
             composite: false,
         }
@@ -469,16 +487,17 @@ impl DocumentOps {
         }
     }
 
-    fn render() -> Self {
+    fn rebuild_hit_tester() -> Self {
         DocumentOps {
-            render: true,
+            rebuild_hit_tester: true,
             ..DocumentOps::nop()
         }
     }
 
     fn combine(&mut self, other: Self) {
         self.scroll = self.scroll || other.scroll;
         self.build = self.build || other.build;
+        self.rebuild_hit_tester = self.rebuild_hit_tester || other.rebuild_hit_tester;
         self.render = self.render || other.render;
         self.composite = self.composite || other.composite;
     }
@@ -730,9 +749,8 @@ impl RenderBackend {
                             if let Some(mut built_scene) = built_scene.take() {
                                 doc.new_async_scene_ready(built_scene);
                                 // After applying the new scene we need to
-                                // rebuild the hit-tester, so we trigger a render
-                                // step.
-                                ops = DocumentOps::render();
+                                // rebuild the hit-tester.
+                                ops = DocumentOps::rebuild_hit_tester();
                             }
                             if let Some(tx) = result_tx {
                                 let (resume_tx, resume_rx) = channel();
@@ -766,7 +784,7 @@ impl RenderBackend {
                             self.resource_cache.set_blob_rasterizer(rasterizer);
                         }
 
-                        if !transaction_msg.is_empty() || ops.render {
+                        if !transaction_msg.is_empty() || ops.rebuild_hit_tester {
                             self.update_document(
                                 document_id,
                                 transaction_msg,
@@ -1061,7 +1079,7 @@ impl RenderBackend {
         // fiddle with things after a potentially long scene build, but just
         // before rendering. This is useful for rendering with the latest
         // async transforms.
-        if op.render || transaction_msg.generate_frame {
+        if op.render || op.rebuild_hit_tester || transaction_msg.generate_frame {
             if let Some(ref sampler) = self.sampler {
                 transaction_msg.frame_ops.append(&mut sampler.sample());
             }
@@ -1148,6 +1166,8 @@ impl RenderBackend {
             // new_frame_ready callback below) has the right flags.
             let msg = ResultMsg::PublishPipelineInfo(doc.updated_pipeline_info());
             self.result_tx.send(msg).unwrap();
+        } else if op.rebuild_hit_tester {
+            doc.rebuild_hit_tester();
         }
 
         if transaction_msg.generate_frame {