From 755a158131b3f4bf321cce6990cbc702e9aece5b Mon Sep 17 00:00:00 2001
From: Junyoung Cho <june0.cho@samsung.com>
Date: Mon, 30 Dec 2013 15:16:41 +0900
Subject: [PATCH 1/2] Fix crash on executing URL with hashtag(local bookmark)

---
 src/components/main/compositing/compositor.rs | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/components/main/compositing/compositor.rs b/src/components/main/compositing/compositor.rs
index 7add72d2a0c..ea80fd52539 100644
--- a/src/components/main/compositing/compositor.rs
+++ b/src/components/main/compositing/compositor.rs
@@ -93,7 +93,10 @@ pub struct IOCompositor {
     constellation_chan: ConstellationChan,
 
     /// The channel on which messages can be sent to the profiler.
-    profiler_chan: ProfilerChan
+    profiler_chan: ProfilerChan,
+
+    /// Pending scroll to fragment event, if any 
+    fragment_point: Option<Point2D<f32>>
 }
 
 impl IOCompositor {
@@ -129,7 +132,8 @@ impl IOCompositor {
             zoom_time: 0f64,
             compositor_layer: None,
             constellation_chan: constellation_chan.clone(),
-            profiler_chan: profiler_chan
+            profiler_chan: profiler_chan,
+            fragment_point: None
         }
     }
 
@@ -336,6 +340,13 @@ impl IOCompositor {
                 let page_window = Size2D(window_size.width as f32 / world_zoom,
                                          window_size.height as f32 / world_zoom);
                 assert!(layer.resize(id, new_size, page_window, epoch));
+                match self.fragment_point.take() { 
+                    Some(point) => {
+                        let recomposite = layer.move(point, page_window) | self.recomposite;
+                        self.recomposite = recomposite;
+                    },
+                    None => {}
+                }
                 true
             }
             None => {
@@ -432,13 +443,15 @@ impl IOCompositor {
         let page_window = Size2D(self.window_size.width as f32 / world_zoom,
                                  self.window_size.height as f32 / world_zoom);
         let ask: bool = match self.compositor_layer {
-            Some(ref mut layer) if layer.pipeline.id == id => {
+            Some(ref mut layer) if layer.pipeline.id == id && !layer.hidden => {
                 let recomposite = layer.move(point, page_window) | self.recomposite;
                 self.recomposite = recomposite;
 
                 true
             }
             Some(_) | None => {
+                self.fragment_point = Some(point);
+
                 false
             }
         };

From b065f21c1c0b9e0c9b8e434c98d11c3e6f50bf97 Mon Sep 17 00:00:00 2001
From: Junyoung Cho <june0.cho@samsung.com>
Date: Fri, 3 Jan 2014 16:21:27 +0900
Subject: [PATCH 2/2] Refactor self.recomposite value update

---
 src/components/main/compositing/compositor.rs | 36 +++++++++----------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/components/main/compositing/compositor.rs b/src/components/main/compositing/compositor.rs
index ea80fd52539..f2a86e9ad81 100644
--- a/src/components/main/compositing/compositor.rs
+++ b/src/components/main/compositing/compositor.rs
@@ -333,28 +333,22 @@ impl IOCompositor {
                            id: PipelineId,
                            new_size: Size2D<f32>,
                            epoch: Epoch) {
-        let ask: bool = match self.compositor_layer {
+        let (ask, move): (bool, bool) = match self.compositor_layer {
             Some(ref mut layer) => {
                 let window_size = &self.window_size;
                 let world_zoom = self.world_zoom;
                 let page_window = Size2D(window_size.width as f32 / world_zoom,
                                          window_size.height as f32 / world_zoom);
                 assert!(layer.resize(id, new_size, page_window, epoch));
-                match self.fragment_point.take() { 
-                    Some(point) => {
-                        let recomposite = layer.move(point, page_window) | self.recomposite;
-                        self.recomposite = recomposite;
-                    },
-                    None => {}
-                }
-                true
-            }
-            None => {
-                false
+                let move = self.fragment_point.take().map_default(false, |point| layer.move(point, page_window));
+
+                (true, move)
             }
+            None => (false, false)
         };
 
         if ask {
+            self.recomposite_if(move);
             self.ask_for_tiles();
         }
     }
@@ -442,21 +436,20 @@ impl IOCompositor {
         let world_zoom = self.world_zoom;
         let page_window = Size2D(self.window_size.width as f32 / world_zoom,
                                  self.window_size.height as f32 / world_zoom);
-        let ask: bool = match self.compositor_layer {
+        let (ask, move): (bool, bool) = match self.compositor_layer {
             Some(ref mut layer) if layer.pipeline.id == id && !layer.hidden => {
-                let recomposite = layer.move(point, page_window) | self.recomposite;
-                self.recomposite = recomposite;
 
-                true
+                (true, layer.move(point, page_window))
             }
             Some(_) | None => {
                 self.fragment_point = Some(point);
 
-                false
+                (false, false)
             }
         };
 
         if ask {
+            self.recomposite_if(move);
             self.ask_for_tiles();
         }
     }
@@ -548,10 +541,11 @@ impl IOCompositor {
                                                 cursor.y as f32 / world_zoom);
         let page_window = Size2D(self.window_size.width as f32 / world_zoom,
                                  self.window_size.height as f32 / world_zoom);
+        let mut scroll = false;
         for layer in self.compositor_layer.mut_iter() {
-            let recomposite = layer.scroll(page_delta, page_cursor, page_window) || self.recomposite;
-            self.recomposite = recomposite;
+            scroll = layer.scroll(page_delta, page_cursor, page_window) || scroll;
         }
+        self.recomposite_if(scroll);
         self.ask_for_tiles();
     }
 
@@ -663,4 +657,8 @@ impl IOCompositor {
             self.done = true;
         }
     }
+
+    fn recomposite_if(&mut self, result: bool) {
+        self.recomposite = result || self.recomposite;
+    }
 }