Auto merge of #14141 - samuknet:home-end-key-scroll2, r=glennw

Implement home end key scrolling

<!-- Please describe your changes on the following line: -->
* Refactor all scroll related code to use a new `ScrollLocation` struct which can either be a `delta` (as before) or a `Start` or `End` request, to represent the desire to scroll to the start and end of the page.
Effectively, everywhere a delta was used, there is now a `ScrollLocation` struct instead.

* Add key press listeners for HOME and END keys so as to cause a scroll to be queued with `ScrollLocation::Start` (in HOME case) or `ScrollLocation::End` (in END case).

* These changes depend on added support for the new `ScrollLocation` in webrender and webrender_traits. See servo/webrender#540.

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [ x] These changes fix #13082 (github issue number if applicable).

<!-- Either: -->
- [ ] There are tests for these changes OR
- [x] These changes do not require tests because scrolling I/O

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

<!-- Reviewable:start -->

---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/14141)
<!-- Reviewable:end -->

Author: bors-servo

Cargo.lock

@@ -39,7 +39,7 @@ use style_traits::viewport::ViewportConstraints;
 use time::{precise_time_ns, precise_time_s};
 use touch::{TouchHandler, TouchAction};
 use webrender;
-use webrender_traits::{self, ScrollEventPhase, ServoScrollRootId, LayoutPoint};
+use webrender_traits::{self, ScrollEventPhase, ServoScrollRootId, LayoutPoint, ScrollLocation};
 use windowing::{self, MouseWindowEvent, WindowEvent, WindowMethods, WindowNavigateMsg};
 
 #[derive(Debug, PartialEq)]
@@ -227,8 +227,8 @@ pub struct IOCompositor<Window: WindowMethods> {
 struct ScrollZoomEvent {
     /// Change the pinch zoom level by this factor
     magnification: f32,
-    /// Scroll by this offset
-    delta: TypedPoint2D<f32, DevicePixel>,
+    /// Scroll by this offset, or to Start or End
+    scroll_location: ScrollLocation,
     /// Apply changes to the frame at this location
     cursor: TypedPoint2D<i32, DevicePixel>,
     /// The scroll event phase.
@@ -1037,15 +1037,19 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         match self.touch_handler.on_touch_move(identifier, point) {
             TouchAction::Scroll(delta) => {
                 match point.cast() {
-                    Some(point) => self.on_scroll_window_event(delta, point),
+                    Some(point) => self.on_scroll_window_event(ScrollLocation::Delta(
+                                                               webrender_traits::LayerPoint::from_untyped(
+                                                               &delta.to_untyped())),
+                                                               point),
                     None => error!("Point cast failed."),
                 }
             }
             TouchAction::Zoom(magnification, scroll_delta) => {
                 let cursor = TypedPoint2D::new(-1, -1);  // Make sure this hits the base layer.
                 self.pending_scroll_zoom_events.push(ScrollZoomEvent {
                     magnification: magnification,
-                    delta: scroll_delta,
+                    scroll_location: ScrollLocation::Delta(webrender_traits::LayerPoint::from_untyped(
+                                                           &scroll_delta.to_untyped())),
                     cursor: cursor,
                     phase: ScrollEventPhase::Move(true),
                     event_count: 1,
@@ -1106,7 +1110,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
     }
 
     fn on_scroll_window_event(&mut self,
-                              delta: TypedPoint2D<f32, DevicePixel>,
+                              scroll_location: ScrollLocation,
                               cursor: TypedPoint2D<i32, DevicePixel>) {
         let event_phase = match (self.scroll_in_progress, self.in_scroll_transaction) {
             (false, None) => ScrollEventPhase::Start,
@@ -1117,33 +1121,33 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         self.in_scroll_transaction = Some(Instant::now());
         self.pending_scroll_zoom_events.push(ScrollZoomEvent {
             magnification: 1.0,
-            delta: delta,
+            scroll_location: scroll_location,
             cursor: cursor,
             phase: event_phase,
             event_count: 1,
         });
     }
 
     fn on_scroll_start_window_event(&mut self,
-                                    delta: TypedPoint2D<f32, DevicePixel>,
+                                    scroll_location: ScrollLocation,
                                     cursor: TypedPoint2D<i32, DevicePixel>) {
         self.scroll_in_progress = true;
         self.pending_scroll_zoom_events.push(ScrollZoomEvent {
             magnification: 1.0,
-            delta: delta,
+            scroll_location: scroll_location,
             cursor: cursor,
             phase: ScrollEventPhase::Start,
             event_count: 1,
         });
     }
 
     fn on_scroll_end_window_event(&mut self,
-                                  delta: TypedPoint2D<f32, DevicePixel>,
+                                  scroll_location: ScrollLocation,
                                   cursor: TypedPoint2D<i32, DevicePixel>) {
         self.scroll_in_progress = false;
         self.pending_scroll_zoom_events.push(ScrollZoomEvent {
             magnification: 1.0,
-            delta: delta,
+            scroll_location: scroll_location,
             cursor: cursor,
             phase: ScrollEventPhase::End,
             event_count: 1,
@@ -1156,14 +1160,34 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         // Batch up all scroll events into one, or else we'll do way too much painting.
         let mut last_combined_event: Option<ScrollZoomEvent> = None;
         for scroll_event in self.pending_scroll_zoom_events.drain(..) {
-            let this_delta = scroll_event.delta;
             let this_cursor = scroll_event.cursor;
+
+            let this_delta = match scroll_event.scroll_location {
+                ScrollLocation::Delta(delta) => delta,
+                ScrollLocation::Start | ScrollLocation::End => {
+                    // If this is an event which is scrolling to the start or end of the page,
+                    // disregard other pending events and exit the loop.
+                    last_combined_event = Some(scroll_event);
+                    break;
+                }
+            };
+
             if let Some(combined_event) = last_combined_event {
                 if combined_event.phase != scroll_event.phase {
-                    let delta = (combined_event.delta / self.scale).to_untyped();
+                    let combined_delta = match combined_event.scroll_location {
+                        ScrollLocation::Delta(delta) => delta,
+                        ScrollLocation::Start | ScrollLocation::End => {
+                            // If this is an event which is scrolling to the start or end of the page,
+                            // disregard other pending events and exit the loop.
+                            last_combined_event = Some(scroll_event);
+                            break;
+                        }
+                    };
+                    let delta = (TypedPoint2D::from_untyped(&combined_delta.to_untyped()) / self.scale)
+                                 .to_untyped();
+                    let delta = webrender_traits::LayerPoint::from_untyped(&delta);
                     let cursor =
                         (combined_event.cursor.to_f32() / self.scale).to_untyped();
-                    let delta = webrender_traits::LayerPoint::from_untyped(&delta);
                     let location = webrender_traits::ScrollLocation::Delta(delta);
                     let cursor = webrender_traits::WorldPoint::from_untyped(&cursor);
                     self.webrender_api.scroll(location, cursor, combined_event.phase);
@@ -1175,7 +1199,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                 (last_combined_event @ &mut None, _) => {
                     *last_combined_event = Some(ScrollZoomEvent {
                         magnification: scroll_event.magnification,
-                        delta: this_delta,
+                        scroll_location: ScrollLocation::Delta(webrender_traits::LayerPoint::from_untyped(
+                                                               &this_delta.to_untyped())),
                         cursor: this_cursor,
                         phase: scroll_event.phase,
                         event_count: 1,
@@ -1187,30 +1212,41 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                     // fling. This causes events to get bunched up occasionally, causing
                     // nasty-looking "pops". To mitigate this, during a fling we average
                     // deltas instead of summing them.
-                    let old_event_count =
-                        ScaleFactor::new(last_combined_event.event_count as f32);
-                    last_combined_event.event_count += 1;
-                    let new_event_count =
-                        ScaleFactor::new(last_combined_event.event_count as f32);
-                    last_combined_event.delta =
-                        (last_combined_event.delta * old_event_count + this_delta) /
-                        new_event_count;
+                    if let ScrollLocation::Delta(delta) = last_combined_event.scroll_location {
+                        let old_event_count =
+                            ScaleFactor::new(last_combined_event.event_count as f32);
+                        last_combined_event.event_count += 1;
+                        let new_event_count =
+                            ScaleFactor::new(last_combined_event.event_count as f32);
+                        last_combined_event.scroll_location = ScrollLocation::Delta(
+                            (delta * old_event_count + this_delta) /
+                            new_event_count);
+                    }
                 }
                 (&mut Some(ref mut last_combined_event), _) => {
-                    last_combined_event.delta = last_combined_event.delta + this_delta;
-                    last_combined_event.event_count += 1
+                    if let ScrollLocation::Delta(delta) = last_combined_event.scroll_location {
+                        last_combined_event.scroll_location = ScrollLocation::Delta(delta + this_delta);
+                        last_combined_event.event_count += 1
+                    }
                 }
             }
         }
 
         // TODO(gw): Support zoom (WR issue #28).
         if let Some(combined_event) = last_combined_event {
-            let delta = (combined_event.delta / self.scale).to_untyped();
-            let delta = webrender_traits::LayoutPoint::from_untyped(&delta);
+            let scroll_location = match combined_event.scroll_location {
+                ScrollLocation::Delta(delta) => {
+                    let scaled_delta = (TypedPoint2D::from_untyped(&delta.to_untyped()) / self.scale)
+                                       .to_untyped();
+                    let calculated_delta = webrender_traits::LayoutPoint::from_untyped(&scaled_delta);
+                                           ScrollLocation::Delta(calculated_delta)
+                },
+                // Leave ScrollLocation unchanged if it is Start or End location.
+                sl @ ScrollLocation::Start | sl @ ScrollLocation::End => sl,
+            };
             let cursor = (combined_event.cursor.to_f32() / self.scale).to_untyped();
-            let location = webrender_traits::ScrollLocation::Delta(delta);
             let cursor = webrender_traits::WorldPoint::from_untyped(&cursor);
-            self.webrender_api.scroll(location, cursor, combined_event.phase);
+            self.webrender_api.scroll(scroll_location, cursor, combined_event.phase);
             self.waiting_for_results_of_scroll = true
         }
 
@@ -1305,7 +1341,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
     fn on_pinch_zoom_window_event(&mut self, magnification: f32) {
         self.pending_scroll_zoom_events.push(ScrollZoomEvent {
             magnification: magnification,
-            delta: TypedPoint2D::zero(), // TODO: Scroll to keep the center in view?
+            scroll_location: ScrollLocation::Delta(TypedPoint2D::zero()), // TODO: Scroll to keep the center in view?
             cursor:  TypedPoint2D::new(-1, -1), // Make sure this hits the base layer.
             phase: ScrollEventPhase::Move(true),
             event_count: 1,
@@ -1703,6 +1739,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
     }
 }
 
+
 /// Why we performed a composite. This is used for debugging.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum CompositingReason {

components/compositing/compositor.rs

@@ -16,6 +16,7 @@ use servo_geometry::ScreenPx;
 use servo_url::ServoUrl;
 use std::fmt::{Debug, Error, Formatter};
 use style_traits::cursor::Cursor;
+use webrender_traits::ScrollLocation;
 
 #[derive(Clone)]
 pub enum MouseWindowEvent {
@@ -62,7 +63,7 @@ pub enum WindowEvent {
     Touch(TouchEventType, TouchId, TypedPoint2D<f32, DevicePixel>),
     /// Sent when the user scrolls. The first point is the delta and the second point is the
     /// origin.
-    Scroll(TypedPoint2D<f32, DevicePixel>, TypedPoint2D<i32, DevicePixel>, TouchEventType),
+    Scroll(ScrollLocation, TypedPoint2D<i32, DevicePixel>, TouchEventType),
     /// Sent when the user zooms.
     Zoom(f32),
     /// Simulated "pinch zoom" gesture for non-touch platforms (e.g. ctrl-scrollwheel).

components/compositing/windowing.rs

@@ -23,6 +23,10 @@ servo_config = {path = "../../components/config"}
 servo_url = {path = "../../components/url"}
 style_traits = {path = "../../components/style_traits"}
 
+[dependencies.webrender_traits]
+git = "https://github.com/servo/webrender"
+default_features = false
+
 [target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
 osmesa-sys = "0.1.2"
 

ports/glutin/Cargo.toml

@@ -22,6 +22,8 @@ extern crate servo_config;
 extern crate servo_geometry;
 extern crate servo_url;
 extern crate style_traits;
+extern crate webrender_traits;
+
 #[cfg(target_os = "windows")] extern crate winapi;
 #[cfg(target_os = "windows")] extern crate user32;
 #[cfg(target_os = "windows")] extern crate gdi32;

ports/glutin/lib.rs

@@ -42,6 +42,7 @@ use std::sync::mpsc::{Sender, channel};
 use style_traits::cursor::Cursor;
 #[cfg(target_os = "windows")]
 use user32;
+use webrender_traits::ScrollLocation;
 #[cfg(target_os = "windows")]
 use winapi;
 
@@ -425,8 +426,9 @@ impl Window {
                     MouseScrollDelta::LineDelta(dx, dy) => (dx, dy * LINE_HEIGHT),
                     MouseScrollDelta::PixelDelta(dx, dy) => (dx, dy),
                 };
+                let scroll_location = ScrollLocation::Delta(TypedPoint2D::new(dx, dy));
                 let phase = glutin_phase_to_touch_event_type(phase);
-                self.scroll_window(dx, dy, phase);
+                self.scroll_window(scroll_location, phase);
             },
             Event::Touch(touch) => {
                 use script_traits::TouchId;
@@ -461,16 +463,19 @@ impl Window {
     }
 
     /// Helper function to send a scroll event.
-    fn scroll_window(&self, mut dx: f32, mut dy: f32, phase: TouchEventType) {
+    fn scroll_window(&self, scroll_location: ScrollLocation, phase: TouchEventType) {
         // Scroll events snap to the major axis of movement, with vertical
         // preferred over horizontal.
-        if dy.abs() >= dx.abs() {
-            dx = 0.0;
-        } else {
-            dy = 0.0;
+        if let ScrollLocation::Delta(mut delta) = scroll_location {
+            if delta.y.abs() >= delta.x.abs() {
+                delta.x = 0.0;
+            } else {
+                delta.y = 0.0;
+            }
         }
+
         let mouse_pos = self.mouse_pos.get();
-        let event = WindowEvent::Scroll(TypedPoint2D::new(dx as f32, dy as f32),
+        let event = WindowEvent::Scroll(scroll_location,
                                         TypedPoint2D::new(mouse_pos.x as i32, mouse_pos.y as i32),
                                         phase);
         self.event_queue.borrow_mut().push(event);
@@ -1034,33 +1039,46 @@ impl WindowMethods for Window {
 
             (NONE, None, Key::PageDown) |
             (NONE, Some(' '), _) => {
-                self.scroll_window(0.0,
+               let scroll_location = ScrollLocation::Delta(TypedPoint2D::new(0.0,
                                    -self.framebuffer_size()
                                         .to_f32()
                                         .to_untyped()
-                                        .height + 2.0 * LINE_HEIGHT,
+                                        .height + 2.0 * LINE_HEIGHT));
+                self.scroll_window(scroll_location,
                                    TouchEventType::Move);
             }
             (NONE, None, Key::PageUp) |
             (SHIFT, Some(' '), _) => {
-                self.scroll_window(0.0,
+                let scroll_location = ScrollLocation::Delta(TypedPoint2D::new(0.0,
                                    self.framebuffer_size()
                                        .to_f32()
                                        .to_untyped()
-                                       .height - 2.0 * LINE_HEIGHT,
+                                       .height - 2.0 * LINE_HEIGHT));
+                self.scroll_window(scroll_location,
                                    TouchEventType::Move);
             }
+
+            (NONE, None, Key::Home) => {
+                self.scroll_window(ScrollLocation::Start, TouchEventType::Move);
+            }
+
+            (NONE, None, Key::End) => {
+                self.scroll_window(ScrollLocation::End, TouchEventType::Move);
+            }
+
             (NONE, None, Key::Up) => {
-                self.scroll_window(0.0, 3.0 * LINE_HEIGHT, TouchEventType::Move);
+                self.scroll_window(ScrollLocation::Delta(TypedPoint2D::new(0.0, 3.0 * LINE_HEIGHT)),
+                                   TouchEventType::Move);
             }
             (NONE, None, Key::Down) => {
-                self.scroll_window(0.0, -3.0 * LINE_HEIGHT, TouchEventType::Move);
+                self.scroll_window(ScrollLocation::Delta(TypedPoint2D::new(0.0, -3.0 * LINE_HEIGHT)),
+                                   TouchEventType::Move);
             }
             (NONE, None, Key::Left) => {
-                self.scroll_window(LINE_HEIGHT, 0.0, TouchEventType::Move);
+                self.scroll_window(ScrollLocation::Delta(TypedPoint2D::new(LINE_HEIGHT, 0.0)), TouchEventType::Move);
             }
             (NONE, None, Key::Right) => {
-                self.scroll_window(-LINE_HEIGHT, 0.0, TouchEventType::Move);
+                self.scroll_window(ScrollLocation::Delta(TypedPoint2D::new(-LINE_HEIGHT, 0.0)), TouchEventType::Move);
             }
             (CMD_OR_CONTROL, Some('r'), _) => {
                 if let Some(true) = PREFS.get("shell.builtin-key-shortcuts.enabled").as_boolean() {