Merge pull request #2861 from Ms2ger/xhr-worker

Support XMLHttpRequest in workers: r=larsbergstrom

src/components/script/dom/bindings/global.rs

@@ -8,9 +8,10 @@ use dom::bindings::js::{JS, JSRef, Root};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::workerglobalscope::WorkerGlobalScope;
 use dom::window::Window;
-use page::Page;
 use script_task::ScriptChan;
 
+use servo_net::resource_task::ResourceTask;
+
 use js::jsapi::JSContext;
 
 use url::Url;
@@ -46,16 +47,25 @@ impl<'a> GlobalRef<'a> {
         }
     }
 
-    pub fn page<'b>(&'b self) -> &'b Page {
+    pub fn resource_task(&self) -> ResourceTask {
-        self.as_window().page()
+        match *self {
+            Window(ref window) => window.page().resource_task.deref().clone(),
+            Worker(ref worker) => worker.resource_task().clone(),
+        }
     }
 
     pub fn get_url(&self) -> Url {
-        self.as_window().get_url()
+        match *self {
+            Window(ref window) => window.get_url(),
+            Worker(ref worker) => worker.get_url().clone(),
+        }
     }
 
     pub fn script_chan<'b>(&'b self) -> &'b ScriptChan {
-        &self.as_window().script_chan
+        match *self {
+            Window(ref window) => &window.script_chan,
+            Worker(ref worker) => worker.script_chan(),
+        }
     }
 }
 

src/components/script/dom/dedicatedworkerglobalscope.rs

@@ -4,17 +4,23 @@
 
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding;
 use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
-use dom::bindings::js::Temporary;
+use dom::bindings::js::{Temporary, RootCollection};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::eventtarget::EventTarget;
 use dom::eventtarget::WorkerGlobalScopeTypeId;
 use dom::workerglobalscope::DedicatedGlobalScope;
 use dom::workerglobalscope::WorkerGlobalScope;
-use script_task::ScriptTask;
+use script_task::{ScriptTask, ScriptChan};
+use script_task::StackRootTLS;
+
+use servo_net::resource_task::{ResourceTask, load_whole_resource};
 
 use js::rust::Cx;
 
 use std::rc::Rc;
+use native;
+use rustrt::task::TaskOpts;
+use url::Url;
 
 #[deriving(Encodable)]
 pub struct DedicatedWorkerGlobalScope {
@@ -22,24 +28,58 @@ pub struct DedicatedWorkerGlobalScope {
 }
 
 impl DedicatedWorkerGlobalScope {
-    pub fn new_inherited(cx: Rc<Cx>) -> DedicatedWorkerGlobalScope {
+    pub fn new_inherited(worker_url: Url,
+                         cx: Rc<Cx>,
+                         resource_task: ResourceTask,
+                         script_chan: ScriptChan)
+                         -> DedicatedWorkerGlobalScope {
         DedicatedWorkerGlobalScope {
-            workerglobalscope: WorkerGlobalScope::new_inherited(DedicatedGlobalScope, cx),
+            workerglobalscope: WorkerGlobalScope::new_inherited(
+                DedicatedGlobalScope, worker_url, cx, resource_task,
+                script_chan),
         }
     }
 
-    pub fn new(cx: Rc<Cx>) -> Temporary<DedicatedWorkerGlobalScope> {
+    pub fn new(worker_url: Url,
-        let scope = box DedicatedWorkerGlobalScope::new_inherited(cx.clone());
+               cx: Rc<Cx>,
+               resource_task: ResourceTask,
+               script_chan: ScriptChan)
+               -> Temporary<DedicatedWorkerGlobalScope> {
+        let scope = box DedicatedWorkerGlobalScope::new_inherited(
+            worker_url, cx.clone(), resource_task, script_chan);
         DedicatedWorkerGlobalScopeBinding::Wrap(cx.ptr, scope)
     }
+}
 
-    pub fn init() -> Temporary<DedicatedWorkerGlobalScope> {
+impl DedicatedWorkerGlobalScope {
-        let (_js_runtime, js_context) = ScriptTask::new_rt_and_cx();
+    pub fn run_worker_scope(worker_url: Url, resource_task: ResourceTask,
-        DedicatedWorkerGlobalScope::new(js_context.clone())
+                            script_chan: ScriptChan) {
-    }
+        let mut task_opts = TaskOpts::new();
+        task_opts.name = Some(format!("Web Worker at {}", worker_url).into_maybe_owned());
+        native::task::spawn_opts(task_opts, proc() {
+            let roots = RootCollection::new();
+            let _stack_roots_tls = StackRootTLS::new(&roots);
 
-    pub fn get_rust_cx<'a>(&'a self) -> &'a Rc<Cx> {
+            let (filename, source) = match load_whole_resource(&resource_task, worker_url.clone()) {
-        self.workerglobalscope.get_rust_cx()
+                Err(_) => {
+                    println!("error loading script {}", worker_url);
+                    return;
+                }
+                Ok((metadata, bytes)) => {
+                    (metadata.final_url, String::from_utf8(bytes).unwrap())
+                }
+            };
+
+            let (_js_runtime, js_context) = ScriptTask::new_rt_and_cx();
+            let global = DedicatedWorkerGlobalScope::new(
+                worker_url, js_context.clone(), resource_task,
+                script_chan).root();
+            match js_context.evaluate_script(
+                global.reflector().get_jsobject(), source, filename.to_str(), 1) {
+                Ok(_) => (),
+                Err(_) => println!("evaluate_script failed")
+            }
+        });
     }
 }
 

src/components/script/dom/worker.rs

@@ -5,19 +5,14 @@
 use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::error::{Fallible, Syntax};
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{Temporary, RootCollection};
+use dom::bindings::js::Temporary;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
 use dom::eventtarget::{EventTarget, WorkerTypeId};
-use script_task::StackRootTLS;
 
-use servo_net::resource_task::load_whole_resource;
 use servo_util::str::DOMString;
 use servo_util::url::try_parse_url;
 
-use native;
-use rustrt::task::TaskOpts;
-
 #[deriving(Encodable)]
 pub struct Worker {
     eventtarget: EventTarget,
@@ -44,32 +39,8 @@ impl Worker {
             Err(_) => return Err(Syntax),
         };
 
-        let resource_task = global.page().resource_task.deref().clone();
+        let resource_task = global.resource_task();
-
+        DedicatedWorkerGlobalScope::run_worker_scope(worker_url, resource_task, global.script_chan().clone());
-        let mut task_opts = TaskOpts::new();
-        task_opts.name = Some(format!("Web Worker at {}", worker_url).into_maybe_owned());
-        native::task::spawn_opts(task_opts, proc() {
-            let roots = RootCollection::new();
-            let _stack_roots_tls = StackRootTLS::new(&roots);
-
-            let (filename, source) = match load_whole_resource(&resource_task, worker_url.clone()) {
-                Err(_) => {
-                    println!("error loading script {}", worker_url);
-                    return;
-                }
-                Ok((metadata, bytes)) => {
-                    (metadata.final_url, String::from_utf8(bytes).unwrap())
-                }
-            };
-
-            let global = DedicatedWorkerGlobalScope::init().root();
-            match global.get_rust_cx().evaluate_script(
-                global.reflector().get_jsobject(), source, filename.to_str(), 1) {
-                Ok(_) => (),
-                Err(_) => println!("evaluate_script failed")
-            }
-        });
-
         Ok(Worker::new(global))
     }
 }

src/components/script/dom/workerglobalscope.rs

@@ -8,12 +8,16 @@ use dom::bindings::js::{JS, JSRef, Temporary, OptionalSettable};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::console::Console;
 use dom::eventtarget::{EventTarget, WorkerGlobalScopeTypeId};
+use script_task::ScriptChan;
+
+use servo_net::resource_task::ResourceTask;
 
 use js::jsapi::JSContext;
 use js::rust::Cx;
 
 use std::cell::Cell;
 use std::rc::Rc;
+use url::Url;
 
 #[deriving(PartialEq,Encodable)]
 pub enum WorkerGlobalScopeId {
@@ -23,26 +27,44 @@ pub enum WorkerGlobalScopeId {
 #[deriving(Encodable)]
 pub struct WorkerGlobalScope {
     pub eventtarget: EventTarget,
+    worker_url: Untraceable<Url>,
     js_context: Untraceable<Rc<Cx>>,
+    resource_task: Untraceable<ResourceTask>,
+    script_chan: ScriptChan,
     console: Cell<Option<JS<Console>>>,
 }
 
 impl WorkerGlobalScope {
     pub fn new_inherited(type_id: WorkerGlobalScopeId,
-                         cx: Rc<Cx>) -> WorkerGlobalScope {
+                         worker_url: Url,
+                         cx: Rc<Cx>,
+                         resource_task: ResourceTask,
+                         script_chan: ScriptChan) -> WorkerGlobalScope {
         WorkerGlobalScope {
             eventtarget: EventTarget::new_inherited(WorkerGlobalScopeTypeId(type_id)),
+            worker_url: Untraceable::new(worker_url),
             js_context: Untraceable::new(cx),
+            resource_task: Untraceable::new(resource_task),
+            script_chan: script_chan,
             console: Cell::new(None),
         }
     }
 
-    pub fn get_rust_cx<'a>(&'a self) -> &'a Rc<Cx> {
-        &*self.js_context
-    }
     pub fn get_cx(&self) -> *mut JSContext {
         self.js_context.ptr
     }
+
+    pub fn resource_task<'a>(&'a self) -> &'a ResourceTask {
+        &*self.resource_task
+    }
+
+    pub fn get_url<'a>(&'a self) -> &'a Url {
+        &*self.worker_url
+    }
+
+    pub fn script_chan<'a>(&'a self) -> &'a ScriptChan {
+        &self.script_chan
+    }
 }
 
 pub trait WorkerGlobalScopeMethods {

src/components/script/dom/xmlhttprequest.rs

@@ -486,7 +486,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
         }
 
         let global = self.global.root();
-        let resource_task = global.root_ref().page().resource_task.deref().clone();
+        let resource_task = global.root_ref().resource_task();
         let mut load_data = LoadData::new(self.request_url.deref().borrow().clone());
         load_data.data = extracted;