Switch android to glutin.

components/servo/.cargo/config

@@ -0,0 +1,2 @@
+[target.arm-linux-androideabi]
+linker = "../../support/android-rs-glue/apk-builder/target/apk-builder"

components/servo/Cargo.lock

@@ -17,7 +17,7 @@ dependencies = [
 [[package]]
 name = "android_glue"
 version = "0.0.1"
-source = "git+https://github.com/tomaka/android-rs-glue#fe9acb5bd465da1df4561e2bd4ebcc6d305134a4"
+source = "git+https://github.com/tomaka/android-rs-glue#cac0adb90bc576758f1ebf3b5e567961b1605c1f"
 dependencies = [
  "compile_msg 0.1.1 (git+https://github.com/huonw/compile_msg)",
 ]
@@ -299,7 +299,7 @@ dependencies = [
 [[package]]
 name = "glutin"
 version = "0.0.2"
-source = "git+https://github.com/tomaka/glutin#c95b778e2c077c0b410f366ad3c85a93c40c6095"
+source = "git+https://github.com/tomaka/glutin#749c47d8c20af078b06e8506b68a54e3799c1a8b"
 dependencies = [
  "android_glue 0.0.1 (git+https://github.com/tomaka/android-rs-glue)",
  "cocoa 0.1.1 (git+https://github.com/servo/rust-cocoa)",

components/servo/main.rs

@@ -5,103 +5,169 @@
 #![comment = "The Servo Parallel Browser Project"]
 #![license = "MPL"]
 
+#![feature(phase)]
+
 #![deny(unused_imports)]
 #![deny(unused_variables)]
 
+#[cfg(target_os="android")]
+extern crate libc;
+
 extern crate servo;
 extern crate native;
 extern crate time;
 extern crate "util" as servo_util;
 
-#[cfg(all(feature = "glutin",not(any(test,target_os="android"))))]
+#[cfg(all(feature = "glutin",not(test)))]
 extern crate "glutin_app" as app;
-#[cfg(all(feature = "glfw_app",not(any(test,target_os="android"))))]
+#[cfg(all(feature = "glfw_app",not(test)))]
 extern crate "glfw_app" as app;
 
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(not(test))]
 extern crate compositing;
 
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(target_os="android")]
+#[phase(plugin, link)]
+extern crate android_glue;
+
+#[cfg(target_os="android")]
+use libc::c_int;
+
+#[cfg(not(test))]
 use servo_util::opts;
 
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(not(test))]
 use servo_util::rtinstrument;
 
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(not(test))]
 use servo::Browser;
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(not(test))]
 use compositing::windowing::{IdleWindowEvent, InitializeCompositingWindowEvent, ResizeWindowEvent};
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(not(test))]
 use compositing::windowing::{WindowEvent};
 
 #[cfg(not(any(test,target_os="android")))]
 use std::os;
 
-#[cfg(not(any(test,target_os="android")))]
+#[cfg(not(test))]
 struct BrowserWrapper {
     browser: Browser<app::window::Window>,
 }
 
-#[cfg(not(any(test,target_os="android")))]
-#[start]
-#[allow(dead_code)]
-fn start(argc: int, argv: *const *const u8) -> int {
-    native::start(argc, argv, proc() {
-        if opts::from_cmdline_args(os::args().as_slice()) {
-            let window = if opts::get().headless {
-                None
-            } else {
-                Some(app::create_window())
-            };
+#[cfg(target_os="android")]
+android_start!(main)
 
-            let mut browser = BrowserWrapper {
-                browser: Browser::new(window.clone()),
-            };
-
-            match window {
-                None => {}
-                Some(ref window) => {
-                    unsafe {
-                        window.set_nested_event_loop_listener(&mut browser);
-                    }
-                }
-            }
-
-            browser.browser.handle_event(InitializeCompositingWindowEvent);
-
-            loop {
-                let should_continue = match window {
-                    None => browser.browser.handle_event(IdleWindowEvent),
-                    Some(ref window) => {
-                        let event = window.wait_events();
-                        browser.browser.handle_event(event)
-                    }
-                };
-                if !should_continue {
-                    break
-                }
-            }
-
-            match window {
-                None => {}
-                Some(ref window) => {
-                    unsafe {
-                        window.remove_nested_event_loop_listener();
-                    }
-                }
-            }
-
-            let BrowserWrapper {
-                browser
-            } = browser;
-            browser.shutdown();
-
-            rtinstrument::teardown();
-        }
-    })
+#[cfg(target_os="android")]
+fn get_args() -> Vec<String> {
+    vec![
+        "servo".to_string(),
+        "http://en.wikipedia.org/wiki/Rust".to_string()
+    ]
+}
+
+#[cfg(not(target_os="android"))]
+fn get_args() -> Vec<String> {
+    os::args()
+}
+
+#[cfg(target_os="android")]
+fn redirect_output(file_no: c_int) {
+    use libc::funcs::posix88::unistd::{pipe, dup2};
+    use libc::funcs::posix88::stdio::fdopen;
+    use libc::c_char;
+    use libc::funcs::c95::stdio::fgets;
+    use std::mem;
+    use std::c_str::CString;
+
+    unsafe {
+        let mut pipes: [c_int, ..2] = [ 0, 0 ];
+        pipe(pipes.as_mut_ptr());
+        dup2(pipes[1], file_no);
+        let input_file = "r".with_c_str(|mode| {
+            fdopen(pipes[0], mode)
+        });
+        spawn(proc() {
+            loop {
+                let mut read_buffer: [c_char, ..1024] = mem::zeroed();
+                fgets(read_buffer.as_mut_ptr(), read_buffer.len() as i32, input_file);
+                let cs = CString::new(read_buffer.as_ptr(), false);
+                match cs.as_str() {
+                    Some(s) => android_glue::write_log(s),
+                    None => {},
+                }
+            }
+        });
+    }
+}
+
+#[cfg(target_os="android")]
+fn setup_logging() {
+    use libc::consts::os::posix88::{STDERR_FILENO, STDOUT_FILENO};
+    //os::setenv("RUST_LOG", "servo,gfx,msg,util,layers,js,glut,std,rt,extra");
+    redirect_output(STDERR_FILENO);
+    redirect_output(STDOUT_FILENO);
+}
+
+#[cfg(not(target_os="android"))]
+fn setup_logging() {
+}
+
+fn main() {
+    if opts::from_cmdline_args(get_args().as_slice()) {
+        setup_logging();
+
+        let window = if opts::get().headless {
+            None
+        } else {
+            Some(app::create_window())
+        };
+
+        let mut browser = BrowserWrapper {
+            browser: Browser::new(window.clone()),
+        };
+
+        match window {
+            None => {}
+            Some(ref window) => {
+                unsafe {
+                    window.set_nested_event_loop_listener(&mut browser);
+                }
+            }
+        }
+
+        browser.browser.handle_event(InitializeCompositingWindowEvent);
+
+        loop {
+            let should_continue = match window {
+                None => browser.browser.handle_event(IdleWindowEvent),
+                Some(ref window) => {
+                    let event = window.wait_events();
+                    browser.browser.handle_event(event)
+                }
+            };
+            if !should_continue {
+                break
+            }
+        };
+
+        match window {
+            None => {}
+            Some(ref window) => {
+                unsafe {
+                    window.remove_nested_event_loop_listener();
+                }
+            }
+        }
+
+        let BrowserWrapper {
+            browser
+        } = browser;
+        browser.shutdown();
+
+        rtinstrument::teardown();
+    }
 }
 
-#[cfg(not(any(test,target_os="android")))]
 impl app::NestedEventLoopListener for BrowserWrapper {
     fn handle_event_from_nested_event_loop(&mut self, event: WindowEvent) -> bool {
         let is_resize = match event {