Cargoify servo

components/msg/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+
+name = "msg"
+version = "0.0.1"
+authors = ["The Servo Project Developers"]
+
+[lib]
+name = "msg"
+path = "lib.rs"
+
+[dependencies.util]
+path = "../util"
+
+[dependencies.azure]
+git = "http://github.com/servo/rust-azure"
+
+[dependencies.geom]
+git = "http://github.com/servo/rust-geom"
+
+[dependencies.layers]
+git = "http://github.com/servo/rust-layers"
+
+[dependencies.core_foundation]
+git = "http://github.com/servo/rust-core-foundation"
+
+[dependencies.io_surface]
+git = "http://github.com/servo/rust-io-surface"
+
+[dependencies.url]
+git = "http://github.com/servo/rust-url"

components/msg/compositor_msg.rs

@@ -0,0 +1,123 @@
+/* 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 azure::azure_hl::Color;
+use geom::point::Point2D;
+use geom::rect::Rect;
+use layers::platform::surface::NativeGraphicsMetadata;
+use layers::layers::LayerBufferSet;
+use serialize::{Encoder, Encodable};
+use std::fmt::{Formatter, Show};
+use std::fmt;
+
+use constellation_msg::PipelineId;
+
+/// The status of the renderer.
+#[deriving(PartialEq, Clone)]
+pub enum RenderState {
+    IdleRenderState,
+    RenderingRenderState,
+}
+
+#[deriving(PartialEq, Clone)]
+pub enum ReadyState {
+    /// Informs the compositor that nothing has been done yet. Used for setting status
+    Blank,
+    /// Informs the compositor that a page is loading. Used for setting status
+    Loading,
+    /// Informs the compositor that a page is performing layout. Used for setting status
+    PerformingLayout,
+    /// Informs the compositor that a page is finished loading. Used for setting status
+    FinishedLoading,
+}
+
+/// A newtype struct for denoting the age of messages; prevents race conditions.
+#[deriving(PartialEq)]
+pub struct Epoch(pub uint);
+
+impl Epoch {
+    pub fn next(&mut self) {
+        let Epoch(ref mut u) = *self;
+        *u += 1;
+    }
+}
+
+#[deriving(Clone, PartialEq)]
+pub struct LayerId(pub uint, pub uint);
+
+impl Show for LayerId {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let LayerId(a, b) = *self;
+        write!(f, "Layer({}, {})", a, b)
+    }
+}
+
+impl LayerId {
+    /// FIXME(#2011, pcwalton): This is unfortunate. Maybe remove this in the future.
+    pub fn null() -> LayerId {
+        LayerId(0, 0)
+    }
+}
+
+/// The scrolling policy of a layer.
+#[deriving(PartialEq)]
+pub enum ScrollPolicy {
+    /// These layers scroll when the parent receives a scrolling message.
+    Scrollable,
+    /// These layers do not scroll when the parent receives a scrolling message.
+    FixedPosition,
+}
+
+/// All layer-specific information that the painting task sends to the compositor other than the
+/// buffer contents of the layer itself.
+pub struct LayerMetadata {
+    /// An opaque ID. This is usually the address of the flow and index of the box within it.
+    pub id: LayerId,
+    /// The position and size of the layer in pixels.
+    pub position: Rect<uint>,
+    /// The background color of the layer.
+    pub background_color: Color,
+    /// The scrolling policy of this layer.
+    pub scroll_policy: ScrollPolicy,
+}
+
+/// The interface used by the renderer to acquire draw targets for each render frame and
+/// submit them to be drawn to the display.
+pub trait RenderListener {
+    fn get_graphics_metadata(&self) -> Option<NativeGraphicsMetadata>;
+
+    /// Informs the compositor of the layers for the given pipeline. The compositor responds by
+    /// creating and/or destroying render layers as necessary.
+    fn initialize_layers_for_pipeline(&self,
+                                      pipeline_id: PipelineId,
+                                      metadata: Vec<LayerMetadata>,
+                                      epoch: Epoch);
+
+    /// Sends new tiles for the given layer to the compositor.
+    fn paint(&self,
+             pipeline_id: PipelineId,
+             epoch: Epoch,
+             replies: Vec<(LayerId, Box<LayerBufferSet>)>);
+
+    fn render_msg_discarded(&self);
+    fn set_render_state(&self, render_state: RenderState);
+}
+
+/// 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.
+pub trait ScriptListener : Clone {
+    fn set_ready_state(&self, ReadyState);
+    fn scroll_fragment_point(&self,
+                             pipeline_id: PipelineId,
+                             layer_id: LayerId,
+                             point: Point2D<f32>);
+    fn close(&self);
+    fn dup(&self) -> Box<ScriptListener>;
+}
+
+impl<E, S: Encoder<E>> Encodable<S, E> for Box<ScriptListener> {
+    fn encode(&self, _s: &mut S) -> Result<(), E> {
+        Ok(())
+    }
+}

components/msg/constellation_msg.rs

@@ -0,0 +1,84 @@
+/* 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/. */
+
+//! The high-level interface from script to constellation. Using this abstract interface helps reduce
+//! coupling between these two components
+
+use geom::rect::Rect;
+use geom::size::TypedSize2D;
+use geom::scale_factor::ScaleFactor;
+use layers::geometry::DevicePixel;
+use serialize::Encodable;
+use servo_util::geometry::{PagePx, ViewportPx};
+use std::comm::{channel, Sender, Receiver};
+use url::Url;
+
+#[deriving(Clone)]
+pub struct ConstellationChan(pub Sender<Msg>);
+
+impl ConstellationChan {
+    pub fn new() -> (Receiver<Msg>, ConstellationChan) {
+        let (chan, port) = channel();
+        (port, ConstellationChan(chan))
+    }
+}
+
+#[deriving(PartialEq)]
+pub enum IFrameSandboxState {
+    IFrameSandboxed,
+    IFrameUnsandboxed
+}
+
+// We pass this info to various tasks, so it lives in a separate, cloneable struct.
+#[deriving(Clone)]
+pub struct Failure {
+    pub pipeline_id: PipelineId,
+    pub subpage_id: Option<SubpageId>,
+}
+
+#[deriving(Encodable)]
+pub struct WindowSizeData {
+    /// The size of the initial layout viewport, before parsing an
+    /// http://www.w3.org/TR/css-device-adapt/#initial-viewport
+    pub initial_viewport: TypedSize2D<ViewportPx, f32>,
+
+    /// The "viewing area" in page px. See `PagePx` documentation for details.
+    pub visible_viewport: TypedSize2D<PagePx, f32>,
+
+    /// The resolution of the window in dppx, not including any "pinch zoom" factor.
+    pub device_pixel_ratio: ScaleFactor<ViewportPx, DevicePixel, f32>,
+}
+
+/// Messages from the compositor and script to the constellation.
+pub enum Msg {
+    ExitMsg,
+    FailureMsg(Failure),
+    InitLoadUrlMsg(Url),
+    LoadCompleteMsg(PipelineId, Url),
+    FrameRectMsg(PipelineId, SubpageId, Rect<f32>),
+    LoadUrlMsg(PipelineId, Url),
+    LoadIframeUrlMsg(Url, PipelineId, SubpageId, IFrameSandboxState),
+    NavigateMsg(NavigationDirection),
+    RendererReadyMsg(PipelineId),
+    ResizedWindowMsg(WindowSizeData),
+}
+
+/// Represents the two different ways to which a page can be navigated
+#[deriving(Clone, PartialEq, Hash)]
+pub enum NavigationType {
+    Load,               // entered or clicked on a url
+    Navigate,           // browser forward/back buttons
+}
+
+#[deriving(Clone, PartialEq, Hash)]
+pub enum NavigationDirection {
+    Forward,
+    Back,
+}
+
+#[deriving(Clone, PartialEq, Eq, Hash, Encodable)]
+pub struct PipelineId(pub uint);
+
+#[deriving(Clone, PartialEq, Eq, Hash, Encodable)]
+pub struct SubpageId(pub uint);

components/msg/lib.rs

@@ -0,0 +1,43 @@
+/* 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/. */
+
+extern crate azure;
+extern crate geom;
+extern crate layers;
+extern crate serialize;
+extern crate servo_util = "util";
+extern crate std;
+extern crate url;
+
+#[cfg(target_os="macos")]
+extern crate core_foundation;
+#[cfg(target_os="macos")]
+extern crate io_surface;
+
+pub mod compositor_msg;
+pub mod constellation_msg;
+
+pub mod platform {
+    #[cfg(target_os="macos")]
+    pub mod macos {
+        #[cfg(target_os="macos")]
+        pub mod surface;
+    }
+
+    #[cfg(target_os="linux")]
+    pub mod linux {
+        #[cfg(target_os="linux")]
+        pub mod surface;
+    }
+
+    #[cfg(target_os="android")]
+    pub mod android {
+        #[cfg(target_os="android")]
+        pub mod surface;
+    }
+
+
+    pub mod surface;
+}
+

components/msg/platform/android/surface.rs

@@ -0,0 +1,20 @@
+/* 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/. */
+
+//! EGL-specific implementation of cross-process surfaces. This uses EGL surfaces.
+
+use platform::surface::NativeSurfaceAzureMethods;
+
+use azure::AzSkiaGrGLSharedSurfaceRef;
+use layers::platform::surface::NativeSurface;
+use std::mem;
+
+impl NativeSurfaceAzureMethods for NativeSurface {
+    fn from_azure_surface(surface: AzSkiaGrGLSharedSurfaceRef) -> NativeSurface {
+        unsafe {
+            NativeSurface::from_image_khr(mem::transmute(surface))
+        }
+    }
+}
+

components/msg/platform/linux/surface.rs

@@ -0,0 +1,20 @@
+/* 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/. */
+
+//! X11-specific implementation of cross-process surfaces. This uses X pixmaps.
+
+use platform::surface::NativeSurfaceAzureMethods;
+
+use azure::AzSkiaGrGLSharedSurfaceRef;
+use layers::platform::surface::NativeSurface;
+use std::mem;
+
+impl NativeSurfaceAzureMethods for NativeSurface {
+    fn from_azure_surface(surface: AzSkiaGrGLSharedSurfaceRef) -> NativeSurface {
+        unsafe {
+            NativeSurface::from_pixmap(mem::transmute(surface))
+        }
+    }
+}
+

components/msg/platform/macos/surface.rs

@@ -0,0 +1,25 @@
+/* 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/. */
+
+//! Mac OS-specific implementation of cross-process surfaces. This uses `IOSurface`, introduced
+//! in Mac OS X 10.6 Snow Leopard.
+
+use platform::surface::NativeSurfaceAzureMethods;
+
+use azure::AzSkiaGrGLSharedSurfaceRef;
+use io_surface::IOSurface;
+use layers::platform::surface::NativeSurface;
+use std::mem;
+
+impl NativeSurfaceAzureMethods for NativeSurface {
+    fn from_azure_surface(surface: AzSkiaGrGLSharedSurfaceRef) -> NativeSurface {
+        unsafe {
+            let io_surface = IOSurface {
+                obj: mem::transmute(surface),
+            };
+            NativeSurface::from_io_surface(io_surface)
+        }
+    }
+}
+

components/msg/platform/surface.rs

@@ -0,0 +1,12 @@
+/* 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/. */
+
+//! Declarations of types for cross-process surfaces.
+
+use azure::AzSkiaGrGLSharedSurfaceRef;
+
+pub trait NativeSurfaceAzureMethods {
+    fn from_azure_surface(surface: AzSkiaGrGLSharedSurfaceRef) -> Self;
+}
+