Upgrade to rustc 1.0.0-dev (47551b574 2015-04-14) (built 2015-03-18)

Author: SimonSapin

Cargo.toml

@@ -6,6 +6,8 @@ authors = ["The Servo Project Developers"]
 
 [dependencies]
 libc = "*"
+rustc-serialize = "*"
+log = "*"
 
 [dependencies.geom]
 

src/color.rs

@@ -7,7 +7,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[derive(Copy)]
+#[derive(Copy, Clone)]
 pub struct Color {
     pub r: f32,
     pub g: f32,

src/geometry.rs

@@ -12,14 +12,14 @@
 /// One hardware pixel.
 ///
 /// This unit corresponds to the smallest addressable element of the display hardware.
-#[derive(Copy, RustcEncodable)]
+#[derive(Copy, Clone, RustcEncodable)]
 pub enum DevicePixel {}
 
 /// One pixel in layer coordinate space.
 ///
 /// This unit corresponds to a "pixel" in layer coordinate space, which after scaling and
 /// transformation becomes a device pixel.
-#[derive(Copy, RustcEncodable)]
+#[derive(Copy, Clone, RustcEncodable)]
 pub enum LayerPixel {}
 
 

src/layers.rs

@@ -19,12 +19,11 @@ use geom::rect::{Rect, TypedRect};
 use platform::surface::{NativeCompositingGraphicsContext, NativePaintingGraphicsContext};
 use platform::surface::NativeSurface;
 use std::cell::{RefCell, RefMut};
-use std::num::Float;
 use std::rc::Rc;
 
 #[derive(Clone, Copy, PartialEq, PartialOrd)]
 pub struct ContentAge {
-    age: uint,
+    age: usize,
 }
 
 impl ContentAge {
@@ -42,7 +41,7 @@ impl ContentAge {
 pub struct Layer<T> {
     pub children: RefCell<Vec<Rc<Layer<T>>>>,
     pub transform: RefCell<Matrix4<f32>>,
-    pub tile_size: uint,
+    pub tile_size: usize,
     pub extra_data: RefCell<T>,
     tile_grid: RefCell<TileGrid>,
 
@@ -67,7 +66,7 @@ pub struct Layer<T> {
 
 impl<T> Layer<T> {
     pub fn new(bounds: TypedRect<LayerPixel, f32>,
-               tile_size: uint,
+               tile_size: usize,
                background_color: Color,
                opacity: f32,
                data: T)
@@ -142,7 +141,7 @@ impl<T> Layer<T> {
 #[derive(Clone, Copy)]
 pub struct BufferRequest {
     // The rect in pixels that will be drawn to the screen
-    pub screen_rect: Rect<uint>,
+    pub screen_rect: Rect<usize>,
 
     // The rect in page coordinates that this tile represents
     pub page_rect: Rect<f32>,
@@ -152,7 +151,7 @@ pub struct BufferRequest {
 }
 
 impl BufferRequest {
-    pub fn new(screen_rect: Rect<uint>,
+    pub fn new(screen_rect: Rect<usize>,
                page_rect: Rect<f32>,
                content_age: ContentAge)
                -> BufferRequest {
@@ -173,13 +172,13 @@ pub struct LayerBuffer {
     pub rect: Rect<f32>,
 
     /// The rect in pixels that will be drawn to the screen.
-    pub screen_pos: Rect<uint>,
+    pub screen_pos: Rect<usize>,
 
     /// The scale at which this tile is rendered
     pub resolution: f32,
 
     /// NB: stride is in pixels, like OpenGL GL_UNPACK_ROW_LENGTH.
-    pub stride: uint,
+    pub stride: usize,
 
     /// Whether or not this buffer was painted with the CPU rasterization.
     pub painted_with_cpu: bool,
@@ -190,7 +189,7 @@ pub struct LayerBuffer {
 
 impl LayerBuffer {
     /// Returns the amount of memory used by the tile
-    pub fn get_mem(&self) -> uint {
+    pub fn get_mem(&self) -> usize {
         // This works for now, but in the future we may want a better heuristic
         self.screen_pos.size.width * self.screen_pos.size.height
     }
@@ -201,7 +200,7 @@ impl LayerBuffer {
     }
 
     /// Returns the Size2D of the tile
-    pub fn get_size_2d(&self) -> Size2D<uint> {
+    pub fn get_size_2d(&self) -> Size2D<usize> {
         self.screen_pos.size
     }
 

src/lib.rs

@@ -10,15 +10,15 @@
 #![crate_name = "layers"]
 #![crate_type = "rlib"]
 
-#![allow(raw_pointer_deriving)]
-#![feature(int_uint)]
+#![allow(raw_pointer_derive)]
+#![feature(collections, std_misc, core)]
 
 extern crate azure;
 extern crate geom;
 extern crate libc;
 #[macro_use]
 extern crate log;
-extern crate "serialize" as rustc_serialize;
+extern crate rustc_serialize;
 extern crate gleam;
 extern crate skia;
 

src/platform/android/surface.rs

@@ -134,10 +134,10 @@ impl EGLImageNativeSurface {
         }
     }
 
-    pub fn get_id(&self) -> int {
+    pub fn get_id(&self) -> isize {
         match self.image {
             None => 0,
-            Some(image_khr) => image_khr as int,
+            Some(image_khr) => image_khr as isize,
         }
     }
 

src/platform/linux/surface.rs

@@ -18,8 +18,8 @@ use libc::{c_char, c_int, c_uint, c_void};
 use glx;
 use gleam::gl;
 use skia::{SkiaSkNativeSharedGLContextRef, SkiaSkNativeSharedGLContextStealSurface};
-use std::ascii::{AsciiExt, OwnedAsciiExt};
-use std::ffi::{CString, c_str_to_bytes};
+use std::ascii::OwnedAsciiExt;
+use std::ffi::{CString, CStr};
 use std::mem;
 use std::ptr;
 use std::str;
@@ -60,7 +60,7 @@ impl NativePaintingGraphicsContext {
 /// someday.
 ///
 /// FIXME(pcwalton): Mark nonsendable.
-#[derive(Copy)]
+#[derive(Copy, Clone)]
 pub struct NativeCompositingGraphicsContext {
     display: *mut Display,
     framebuffer_configuration: Option<glx::types::GLXFBConfig>,
@@ -142,7 +142,7 @@ impl NativeCompositingGraphicsContext {
                 panic!("Could not determine GLX vendor.");
             }
             let glx_vendor =
-                str::from_utf8(c_str_to_bytes(&glx_vendor))
+                str::from_utf8(CStr::from_ptr(glx_vendor).to_bytes())
                     .ok()
                     .expect("GLX client vendor string not in UTF-8 format.");
             let glx_vendor = String::from_str(glx_vendor).into_ascii_lowercase();
@@ -178,7 +178,7 @@ impl NativeGraphicsMetadata {
         // the X Pixmap will not be sharable across them. Using this
         // method breaks that assumption.
         unsafe {
-            let mut c_str = CString::from_slice(descriptor.display.as_bytes());
+            let c_str = CString::new(descriptor.display.as_bytes()).unwrap();
             let display = XOpenDisplay(c_str.as_ptr() as *mut _);
             if display.is_null() {
                 panic!("XOpenDisplay() failed!");
@@ -201,7 +201,7 @@ impl NativeGraphicsMetadataDescriptor {
     pub fn from_metadata(metadata: NativeGraphicsMetadata) -> NativeGraphicsMetadataDescriptor {
         unsafe {
             let c_str = XDisplayString(metadata.display) as *const _;
-            let bytes = c_str_to_bytes(&c_str);
+            let bytes = CStr::from_ptr(c_str).to_bytes();
             NativeGraphicsMetadataDescriptor {
                 display: str::from_utf8(bytes).unwrap().to_string(),
             }
@@ -265,7 +265,7 @@ impl PixmapNativeSurface {
     pub fn bind_to_texture(&self,
                            native_context: &NativeCompositingGraphicsContext,
                            texture: &Texture,
-                           size: Size2D<int>) {
+                           size: Size2D<isize>) {
         // Create the GLX pixmap.
         //
         // FIXME(pcwalton): RAII for exception safety?
@@ -352,8 +352,8 @@ impl PixmapNativeSurface {
         }
     }
 
-    pub fn get_id(&self) -> int {
-        self.pixmap as int
+    pub fn get_id(&self) -> isize {
+        self.pixmap as isize
     }
 
     pub fn destroy(&mut self, graphics_context: &NativePaintingGraphicsContext) {

src/platform/macos/surface.rs

@@ -213,7 +213,7 @@ impl IOSurfaceNativeSurface {
     pub fn bind_to_texture(&self,
                            _: &NativeCompositingGraphicsContext,
                            texture: &Texture,
-                           size: Size2D<int>) {
+                           size: Size2D<isize>) {
         let _bound_texture = texture.bind();
         let io_surface = io_surface::lookup(self.io_surface_id.unwrap());
         io_surface.bind_to_gl_texture(size)
@@ -224,10 +224,10 @@ impl IOSurfaceNativeSurface {
         io_surface.upload(data)
     }
 
-    pub fn get_id(&self) -> int {
+    pub fn get_id(&self) -> isize {
         match self.io_surface_id {
             None => 0,
-            Some(id) => id as int,
+            Some(id) => id as isize,
         }
     }
 

src/platform/surface.rs

@@ -145,7 +145,7 @@ impl NativeSurface {
     pub fn bind_to_texture(&self,
                            native_context: &NativeCompositingGraphicsContext,
                            texture: &Texture,
-                           size: Size2D<int>) {
+                           size: Size2D<isize>) {
         native_surface_method!(self bind_to_texture (native_context, texture, size))
     }
 
@@ -155,7 +155,7 @@ impl NativeSurface {
     }
 
     /// Returns an opaque ID identifying the surface for debugging.
-    pub fn get_id(&self) -> int {
+    pub fn get_id(&self) -> isize {
         native_surface_method!(self get_id ())
     }
 
@@ -205,7 +205,7 @@ impl MemoryBufferNativeSurface {
 
     /// This may only be called on the compositor side.
     #[cfg(not(target_os="android"))]
-    pub fn bind_to_texture(&self, _: &NativeCompositingGraphicsContext, texture: &Texture, size: Size2D<int>) {
+    pub fn bind_to_texture(&self, _: &NativeCompositingGraphicsContext, texture: &Texture, size: Size2D<isize>) {
         let _bound = texture.bind();
         gl::tex_image_2d(gl::TEXTURE_2D,
                          0,
@@ -215,11 +215,11 @@ impl MemoryBufferNativeSurface {
                          0,
                          gl::BGRA,
                          gl::UNSIGNED_BYTE,
-                         Some(self.bytes.as_slice()));
+                         Some(&self.bytes));
     }
 
     #[cfg(target_os="android")]
-    pub fn bind_to_texture(&self, _: &NativeCompositingGraphicsContext, _: &Texture, _: Size2D<int>) {
+    pub fn bind_to_texture(&self, _: &NativeCompositingGraphicsContext, _: &Texture, _: Size2D<isize>) {
         panic!("Binding a memory surface to a texture is not yet supported on Android.");
     }
 
@@ -229,7 +229,7 @@ impl MemoryBufferNativeSurface {
         self.bytes.push_all(data);
     }
 
-    pub fn get_id(&self) -> int {
+    pub fn get_id(&self) -> isize {
         0
     }