diff --git a/components/constellation/constellation.rs b/components/constellation/constellation.rs index 12a641c3c08..ba14a9c8225 100644 --- a/components/constellation/constellation.rs +++ b/components/constellation/constellation.rs @@ -75,6 +75,7 @@ use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg}; use euclid::scale_factor::ScaleFactor; use euclid::size::{Size2D, TypedSize2D}; use event_loop::EventLoop; +use frame::{Frame, FrameChange, FrameTreeIterator, FullFrameTreeIterator}; use gfx::font_cache_thread::FontCacheThread; use gfx_traits::Epoch; use ipc_channel::ipc::{self, IpcSender}; @@ -110,7 +111,6 @@ use std::collections::{HashMap, VecDeque}; use std::io::Error as IOError; use std::iter::once; use std::marker::PhantomData; -use std::mem::replace; use std::process; use std::rc::{Rc, Weak}; use std::sync::Arc; @@ -322,187 +322,6 @@ pub struct InitialConstellationState { pub supports_clipboard: bool, } -/// A frame in the frame tree. -/// Each frame is the constrellation's view of a browsing context. -/// Each browsing context has a session history, caused by -/// navigation and traversing the history. Each frame has its -/// current entry, plus past and future entries. The past is sorted -/// chronologically, the future is sorted reverse chronoogically: -/// in partiucular prev.pop() is the latest past entry, and -/// next.pop() is the earliest future entry. -#[derive(Debug, Clone)] -struct Frame { - /// The frame id. - id: FrameId, - - /// The past session history, ordered chronologically. - prev: Vec, - - /// The currently active session history entry. - current: FrameState, - - /// The future session history, ordered reverse chronologically. - next: Vec, -} - -impl Frame { - /// Create a new frame. - /// Note this just creates the frame, it doesn't add it to the frame tree. - fn new(id: FrameId, pipeline_id: PipelineId) -> Frame { - Frame { - id: id, - prev: vec!(), - current: FrameState::new(pipeline_id, id), - next: vec!(), - } - } - - /// Set the current frame entry, and push the current frame entry into the past. - fn load(&mut self, pipeline_id: PipelineId) { - self.prev.push(self.current.clone()); - self.current = FrameState::new(pipeline_id, self.id); - } - - /// Set the future to be empty. - fn remove_forward_entries(&mut self) -> Vec { - replace(&mut self.next, vec!()) - } - - /// Set the current frame entry, and drop the current frame entry. - fn replace_current(&mut self, pipeline_id: PipelineId) -> FrameState { - replace(&mut self.current, FrameState::new(pipeline_id, self.id)) - } -} - -/// An entry in a frame's session history. -/// Each entry stores the pipeline id for a document in the session history. -/// When we operate on the joint session history, entries are sorted chronologically, -/// so we timestamp the entries by when the entry was added to the session history. -#[derive(Debug, Clone)] -struct FrameState { - /// The timestamp for when the session history entry was created - instant: Instant, - /// The pipeline for the document in the session history - pipeline_id: PipelineId, - /// The frame that this session history entry is part of - frame_id: FrameId, -} - -impl FrameState { - /// Create a new session history entry. - fn new(pipeline_id: PipelineId, frame_id: FrameId) -> FrameState { - FrameState { - instant: Instant::now(), - pipeline_id: pipeline_id, - frame_id: frame_id, - } - } -} - -/// Represents a pending change in the frame tree, that will be applied -/// once the new pipeline has loaded and completed initial layout / paint. -struct FrameChange { - /// The frame to change. - frame_id: FrameId, - - /// The pipeline that was currently active at the time the change started. - /// TODO: can this field be removed? - old_pipeline_id: Option, - - /// The pipeline for the document being loaded. - new_pipeline_id: PipelineId, - - /// Is the new document replacing the current document (e.g. a reload) - /// or pushing it into the session history (e.g. a navigation)? - replace: bool, -} - -/// An iterator over a frame tree, returning the fully active frames in -/// depth-first order. Note that this iterator only returns the fully -/// active frames, that is ones where every ancestor frame is -/// in the currently active pipeline of its parent frame. -struct FrameTreeIterator<'a> { - /// The frames still to iterate over. - stack: Vec, - - /// The set of all frames. - frames: &'a HashMap, - - /// The set of all pipelines. We use this to find the active - /// children of a frame, which are the iframes in the currently - /// active document. - pipelines: &'a HashMap, -} - -impl<'a> Iterator for FrameTreeIterator<'a> { - type Item = &'a Frame; - fn next(&mut self) -> Option<&'a Frame> { - loop { - let frame_id = match self.stack.pop() { - Some(frame_id) => frame_id, - None => return None, - }; - let frame = match self.frames.get(&frame_id) { - Some(frame) => frame, - None => { - warn!("Frame {:?} iterated after closure.", frame_id); - continue; - }, - }; - let pipeline = match self.pipelines.get(&frame.current.pipeline_id) { - Some(pipeline) => pipeline, - None => { - warn!("Pipeline {:?} iterated after closure.", frame.current.pipeline_id); - continue; - }, - }; - self.stack.extend(pipeline.children.iter().map(|&c| c)); - return Some(frame) - } - } -} - -/// An iterator over a frame tree, returning all frames in depth-first -/// order. Note that this iterator returns all frames, not just the -/// fully active ones. -struct FullFrameTreeIterator<'a> { - /// The frames still to iterate over. - stack: Vec, - - /// The set of all frames. - frames: &'a HashMap, - - /// The set of all pipelines. We use this to find the - /// children of a frame, which are the iframes in all documents - /// in the session history. - pipelines: &'a HashMap, -} - -impl<'a> Iterator for FullFrameTreeIterator<'a> { - type Item = &'a Frame; - fn next(&mut self) -> Option<&'a Frame> { - loop { - let frame_id = match self.stack.pop() { - Some(frame_id) => frame_id, - None => return None, - }; - let frame = match self.frames.get(&frame_id) { - Some(frame) => frame, - None => { - warn!("Frame {:?} iterated after closure.", frame_id); - continue; - }, - }; - for entry in frame.prev.iter().chain(frame.next.iter()).chain(once(&frame.current)) { - if let Some(pipeline) = self.pipelines.get(&entry.pipeline_id) { - self.stack.extend(pipeline.children.iter().map(|&c| c)); - } - } - return Some(frame) - } - } -} - /// Data needed for webdriver struct WebDriverData { load_channel: Option<(PipelineId, IpcSender)>, diff --git a/components/constellation/frame.rs b/components/constellation/frame.rs new file mode 100644 index 00000000000..b061e0920ee --- /dev/null +++ b/components/constellation/frame.rs @@ -0,0 +1,192 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use msg::constellation_msg::{FrameId, PipelineId}; +use pipeline::Pipeline; +use std::collections::HashMap; +use std::iter::once; +use std::mem::replace; +use std::time::Instant; + +/// A frame in the frame tree. +/// Each frame is the constrellation's view of a browsing context. +/// Each browsing context has a session history, caused by +/// navigation and traversing the history. Each frame has its +/// current entry, plus past and future entries. The past is sorted +/// chronologically, the future is sorted reverse chronoogically: +/// in partiucular prev.pop() is the latest past entry, and +/// next.pop() is the earliest future entry. +#[derive(Debug, Clone)] +pub struct Frame { + /// The frame id. + pub id: FrameId, + + /// The past session history, ordered chronologically. + pub prev: Vec, + + /// The currently active session history entry. + pub current: FrameState, + + /// The future session history, ordered reverse chronologically. + pub next: Vec, +} + +impl Frame { + /// Create a new frame. + /// Note this just creates the frame, it doesn't add it to the frame tree. + pub fn new(id: FrameId, pipeline_id: PipelineId) -> Frame { + Frame { + id: id, + prev: vec!(), + current: FrameState::new(pipeline_id, id), + next: vec!(), + } + } + + /// Set the current frame entry, and push the current frame entry into the past. + pub fn load(&mut self, pipeline_id: PipelineId) { + self.prev.push(self.current.clone()); + self.current = FrameState::new(pipeline_id, self.id); + } + + /// Set the future to be empty. + pub fn remove_forward_entries(&mut self) -> Vec { + replace(&mut self.next, vec!()) + } + + /// Set the current frame entry, and drop the current frame entry. + pub fn replace_current(&mut self, pipeline_id: PipelineId) -> FrameState { + replace(&mut self.current, FrameState::new(pipeline_id, self.id)) + } +} + +/// An entry in a frame's session history. +/// Each entry stores the pipeline id for a document in the session history. +/// +/// When we operate on the joint session history, entries are sorted chronologically, +/// so we timestamp the entries by when the entry was added to the session history. +#[derive(Debug, Clone)] +pub struct FrameState { + /// The timestamp for when the session history entry was created + pub instant: Instant, + /// The pipeline for the document in the session history + pub pipeline_id: PipelineId, + /// The frame that this session history entry is part of + pub frame_id: FrameId, +} + +impl FrameState { + /// Create a new session history entry. + fn new(pipeline_id: PipelineId, frame_id: FrameId) -> FrameState { + FrameState { + instant: Instant::now(), + pipeline_id: pipeline_id, + frame_id: frame_id, + } + } +} + +/// Represents a pending change in the frame tree, that will be applied +/// once the new pipeline has loaded and completed initial layout / paint. +pub struct FrameChange { + /// The frame to change. + pub frame_id: FrameId, + + /// The pipeline that was currently active at the time the change started. + /// TODO: can this field be removed? + pub old_pipeline_id: Option, + + /// The pipeline for the document being loaded. + pub new_pipeline_id: PipelineId, + + /// Is the new document replacing the current document (e.g. a reload) + /// or pushing it into the session history (e.g. a navigation)? + pub replace: bool, +} + +/// An iterator over a frame tree, returning the fully active frames in +/// depth-first order. Note that this iterator only returns the fully +/// active frames, that is ones where every ancestor frame is +/// in the currently active pipeline of its parent frame. +pub struct FrameTreeIterator<'a> { + /// The frames still to iterate over. + pub stack: Vec, + + /// The set of all frames. + pub frames: &'a HashMap, + + /// The set of all pipelines. We use this to find the active + /// children of a frame, which are the iframes in the currently + /// active document. + pub pipelines: &'a HashMap, +} + +impl<'a> Iterator for FrameTreeIterator<'a> { + type Item = &'a Frame; + fn next(&mut self) -> Option<&'a Frame> { + loop { + let frame_id = match self.stack.pop() { + Some(frame_id) => frame_id, + None => return None, + }; + let frame = match self.frames.get(&frame_id) { + Some(frame) => frame, + None => { + warn!("Frame {:?} iterated after closure.", frame_id); + continue; + }, + }; + let pipeline = match self.pipelines.get(&frame.current.pipeline_id) { + Some(pipeline) => pipeline, + None => { + warn!("Pipeline {:?} iterated after closure.", frame.current.pipeline_id); + continue; + }, + }; + self.stack.extend(pipeline.children.iter().map(|&c| c)); + return Some(frame) + } + } +} + +/// An iterator over a frame tree, returning all frames in depth-first +/// order. Note that this iterator returns all frames, not just the +/// fully active ones. +pub struct FullFrameTreeIterator<'a> { + /// The frames still to iterate over. + pub stack: Vec, + + /// The set of all frames. + pub frames: &'a HashMap, + + /// The set of all pipelines. We use this to find the + /// children of a frame, which are the iframes in all documents + /// in the session history. + pub pipelines: &'a HashMap, +} + +impl<'a> Iterator for FullFrameTreeIterator<'a> { + type Item = &'a Frame; + fn next(&mut self) -> Option<&'a Frame> { + loop { + let frame_id = match self.stack.pop() { + Some(frame_id) => frame_id, + None => return None, + }; + let frame = match self.frames.get(&frame_id) { + Some(frame) => frame, + None => { + warn!("Frame {:?} iterated after closure.", frame_id); + continue; + }, + }; + for entry in frame.prev.iter().chain(frame.next.iter()).chain(once(&frame.current)) { + if let Some(pipeline) = self.pipelines.get(&entry.pipeline_id) { + self.stack.extend(pipeline.children.iter().map(|&c| c)); + } + } + return Some(frame) + } + } +} diff --git a/components/constellation/lib.rs b/components/constellation/lib.rs index b4e6bda940e..adb9e768425 100644 --- a/components/constellation/lib.rs +++ b/components/constellation/lib.rs @@ -44,6 +44,7 @@ extern crate webrender_traits; mod constellation; mod event_loop; +mod frame; mod pipeline; #[cfg(not(target_os = "windows"))] mod sandboxing;