Merging and fix review

Conflicts:
	components/msg/compositor_msg.rs
	components/script/dom/window.rs
	components/script/script_task.rs

components/compositing/compositor_task.rs

@@ -65,7 +65,7 @@ pub fn run_script_listener_thread(compositor_proxy: Box<CompositorProxy + 'stati
                                   receiver: IpcReceiver<ScriptToCompositorMsg>) {
     while let Ok(msg) = receiver.recv() {
         match msg {
-            ScriptToCompositorMsg::ScrollFragmentPoint(pipeline_id, layer_id, point) => {
+            ScriptToCompositorMsg::ScrollFragmentPoint(pipeline_id, layer_id, point, _smooth) => {
                 compositor_proxy.send(Msg::ScrollFragmentPoint(pipeline_id, layer_id, point));
             }
 

components/msg/compositor_msg.rs

@@ -6,6 +6,7 @@ use azure::azure_hl::Color;
 use constellation_msg::{Key, KeyState, KeyModifiers};
 use euclid::{Size2D, Point2D, Rect};
 use euclid::Matrix4;
+use ipc_channel::ipc::IpcSender;
 use layers::platform::surface::NativeDisplay;
 use layers::layers::{BufferRequest, LayerBufferSet};
 use std::fmt::{Formatter, Debug};
@@ -118,60 +119,11 @@ pub trait PaintListener {
 
 #[derive(Deserialize, Serialize)]
 pub enum ScriptToCompositorMsg {
-    ScrollFragmentPoint(PipelineId, LayerId, Point2D<f32>),
+    ScrollFragmentPoint(PipelineId, LayerId, Point2D<f32>, bool),
     SetTitle(PipelineId, Option<String>),
     SendKeyEvent(Key, KeyState, KeyModifiers),
     GetClientWindow(IpcSender<(Size2D<u32>, Point2D<i32>)>),
     MoveTo(Point2D<i32>),
     ResizeTo(Size2D<u32>),
     Exit,
 }
-
-/// The interface used by the script task to tell the compositor to update its ready state,
-/// which is used in displaying the appropriate message in the window's title.
-#[derive(Clone)]
-pub struct ScriptListener(IpcSender<ScriptToCompositorMsg>);
-
-impl ScriptListener {
-    pub fn new(sender: IpcSender<ScriptToCompositorMsg>) -> ScriptListener {
-        ScriptListener(sender)
-    }
-
-    pub fn scroll_fragment_point(&mut self,
-                                 pipeline_id: PipelineId,
-                                 layer_id: LayerId,
-                                 point: Point2D<f32>,
-                                 _smooth: bool) {
-        self.0
-            .send(ScriptToCompositorMsg::ScrollFragmentPoint(pipeline_id, layer_id, point))
-            .unwrap()
-    }
-
-    pub fn client_window(&mut self, send: IpcSender<(Size2D<u32>, Point2D<i32>)>) {
-        self.0.send(ScriptToCompositorMsg::GetClientWindow(send)).unwrap()
-    }
-
-    pub fn move_window(&mut self, point: Point2D<i32>) {
-        self.0.send(ScriptToCompositorMsg::MoveTo(point)).unwrap()
-    }
-
-    pub fn resize_window(&mut self, size: Size2D<u32>) {
-        self.0.send(ScriptToCompositorMsg::ResizeTo(size)).unwrap()
-    }
-
-    pub fn close(&mut self) {
-        self.0.send(ScriptToCompositorMsg::Exit).unwrap()
-    }
-
-    pub fn dup(&mut self) -> ScriptListener {
-        self.clone()
-    }
-
-    pub fn set_title(&mut self, pipeline_id: PipelineId, title: Option<String>) {
-        self.0.send(ScriptToCompositorMsg::SetTitle(pipeline_id, title)).unwrap()
-    }
-
-    pub fn send_key_event(&mut self, key: Key, state: KeyState, modifiers: KeyModifiers) {
-        self.0.send(ScriptToCompositorMsg::SendKeyEvent(key, state, modifiers)).unwrap()
-    }
-}

components/script/dom/window.rs

@@ -42,7 +42,7 @@ use timers::{IsInterval, TimerId, TimerManager, TimerCallback};
 use webdriver_handlers::jsval_to_webdriver;
 use devtools_traits::{ScriptToDevtoolsControlMsg, TimelineMarker, TimelineMarkerType};
 use devtools_traits::{TracingMetadata};
-use msg::compositor_msg::{ScriptListener, LayerId};
+use msg::compositor_msg::{ScriptToCompositorMsg, LayerId};
 use msg::constellation_msg::{LoadData, PipelineId, SubpageId, ConstellationChan, WindowSizeData, WorkerId};
 use msg::webdriver_msg::{WebDriverJSError, WebDriverJSResult};
 use net_traits::ResourceTask;
@@ -686,7 +686,7 @@ impl<'a> WindowMethods for &'a Window {
         // Step 1
         //TODO determine if this operation is allowed
         let size = Size2D::new(x.to_u32().unwrap_or(1), y.to_u32().unwrap_or(1));
-        self.compositor.borrow_mut().resize_window(size)
+        self.compositor.borrow_mut().send(ScriptToCompositorMsg::ResizeTo(size)).unwrap()
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-window-resizeby
@@ -701,7 +701,7 @@ impl<'a> WindowMethods for &'a Window {
         // Step 1
         //TODO determine if this operation is allowed
         let point = Point2D::new(x,y);
-        self.compositor.borrow_mut().move_window(point)
+        self.compositor.borrow_mut().send(ScriptToCompositorMsg::MoveTo(point)).unwrap()
     }
 
     // https://drafts.csswg.org/cssom-view/#dom-window-moveby
@@ -902,15 +902,25 @@ impl<'a> WindowHelpers for &'a Window {
     }
 
     /// https://drafts.csswg.org/cssom-view/#perform-a-scroll
-    fn perform_a_scroll(self, x: f32, y: f32, behavior: ScrollBehavior, _element: Option<&Element>) {
+    fn perform_a_scroll(self, x: f32, y: f32, behavior: ScrollBehavior, element: Option<&Element>) {
         //TODO Step 1
         let point = Point2D::new(x, y);
         let smooth = match behavior {
-            ScrollBehavior::Auto => false, //TODO check css scroll behavior
+            ScrollBehavior::Auto => {
+                element.map(|_element| {
+                    // TODO check computed scroll-behaviour CSS property
+                    true
+                }).unwrap_or(false)
+            }
             ScrollBehavior::Instant => false,
             ScrollBehavior::Smooth => true
         };
-        self.compositor.borrow_mut().scroll_fragment_point(self.pipeline(), LayerId::null(), point, smooth)
+
+        let size = self.current_viewport.get().size;
+        self.current_viewport.set(Rect::new(Point2D::new(Au::from_f32_px(x), Au::from_f32_px(y)), size));
+
+        self.compositor.borrow_mut().send(ScriptToCompositorMsg::ScrollFragmentPoint(
+                                                         self.pipeline(), LayerId::null(), point, smooth)).unwrap()
     }
 
     /// Reflows the page unconditionally. This method will wait for the layout thread to complete
@@ -1032,7 +1042,7 @@ impl<'a> WindowHelpers for &'a Window {
 
     fn client_window(self) -> (Size2D<u32>, Point2D<i32>) {
         let (send,recv) = ipc::channel::<(Size2D<u32>, Point2D<i32>)>().unwrap();
-        self.compositor.borrow_mut().client_window(send);
+        self.compositor.borrow_mut().send(ScriptToCompositorMsg::GetClientWindow(send)).unwrap();
         recv.recv().unwrap_or((Size2D::zero(), Point2D::zero()))
     }
 

components/script/script_task.rs

@@ -1601,7 +1601,8 @@ impl ScriptTask {
         // Really what needs to happen is that this needs to go through layout to ask which
         // layer the element belongs to, and have it send the scroll message to the
         // compositor.
-        self.compositor.borrow_mut().scroll_fragment_point(pipeline_id, LayerId::null(), point, false);
+        self.compositor.borrow_mut().send(ScriptToCompositorMsg::ScrollFragmentPoint(
+                                                 pipeline_id, LayerId::null(), point, false)).unwrap();
     }
 
     /// Reflows non-incrementally, rebuilding the entire layout tree in the process.

tests/html/viewport.html

@@ -14,14 +14,29 @@
         console.log("screenX: "+ window.screenX);
       }
       function test_scroll(){
-        window.scroll(0,100);
+
       }
     </script>
   </head>
   <body>
     <button onclick="show();">Test</button>
-    <div style="background-color: #b0c4de; height:1000px; width:800px;"/>
-    <button onclick="test_scroll();">Scroll</button>
+    <button onclick="window.scroll(0,100);">Scroll</button>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
+    <br/>
     <button onclick="window.moveTo(100,10);">Move</button>
+    <button onclick="window.scroll(0,10);">Scroll 2</button>
+    <div style="background-color: #b0c4de; height:1000px; width:800px;"/>
+    <button onclick="show();">Test</button>
   </body>
 </html>