Auto merge of #7238 - Wafflespeanut:workerglobal, r=Ms2ger

Improved field names for devtools-related channels...

(for #6924) - I took this because the confusion was actually caused by me while working on #6829

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/7238)
<!-- Reviewable:end -->

components/script/dom/dedicatedworkerglobalscope.rs

@@ -157,7 +157,7 @@ impl DedicatedWorkerGlobalScope {
     fn new_inherited(init: WorkerGlobalScopeInit,
                      worker_url: Url,
                      id: PipelineId,
-                     devtools_port: Receiver<DevtoolScriptControlMsg>,
+                     from_devtools_receiver: Receiver<DevtoolScriptControlMsg>,
                      runtime: Rc<Runtime>,
                      parent_sender: Box<ScriptChan + Send>,
                      own_sender: Sender<(TrustedWorkerAddress, WorkerScriptMsg)>,
@@ -166,7 +166,7 @@ impl DedicatedWorkerGlobalScope {
         DedicatedWorkerGlobalScope {
             workerglobalscope: WorkerGlobalScope::new_inherited(
                 WorkerGlobalScopeTypeId::DedicatedGlobalScope, init, worker_url,
-                runtime, devtools_port),
+                runtime, from_devtools_receiver),
             id: id,
             receiver: receiver,
             own_sender: own_sender,
@@ -178,14 +178,14 @@ impl DedicatedWorkerGlobalScope {
     pub fn new(init: WorkerGlobalScopeInit,
                worker_url: Url,
                id: PipelineId,
-               devtools_port: Receiver<DevtoolScriptControlMsg>,
+               from_devtools_receiver: Receiver<DevtoolScriptControlMsg>,
                runtime: Rc<Runtime>,
                parent_sender: Box<ScriptChan + Send>,
                own_sender: Sender<(TrustedWorkerAddress, WorkerScriptMsg)>,
                receiver: Receiver<(TrustedWorkerAddress, WorkerScriptMsg)>)
                -> Root<DedicatedWorkerGlobalScope> {
         let scope = box DedicatedWorkerGlobalScope::new_inherited(
-            init, worker_url, id, devtools_port, runtime.clone(), parent_sender,
+            init, worker_url, id, from_devtools_receiver, runtime.clone(), parent_sender,
             own_sender, receiver);
         DedicatedWorkerGlobalScopeBinding::Wrap(runtime.cx(), scope)
     }
@@ -195,7 +195,7 @@ impl DedicatedWorkerGlobalScope {
     pub fn run_worker_scope(init: WorkerGlobalScopeInit,
                             worker_url: Url,
                             id: PipelineId,
-                            devtools_ipc_port: IpcReceiver<DevtoolScriptControlMsg>,
+                            from_devtools_receiver: IpcReceiver<DevtoolScriptControlMsg>,
                             worker: TrustedWorkerAddress,
                             parent_sender: Box<ScriptChan + Send>,
                             own_sender: Sender<(TrustedWorkerAddress, WorkerScriptMsg)>,
@@ -222,7 +222,7 @@ impl DedicatedWorkerGlobalScope {
             let runtime = Rc::new(ScriptTask::new_rt_and_cx());
 
             let (devtools_mpsc_chan, devtools_mpsc_port) = channel();
-            ROUTER.route_ipc_receiver_to_mpsc_sender(devtools_ipc_port, devtools_mpsc_chan);
+            ROUTER.route_ipc_receiver_to_mpsc_sender(from_devtools_receiver, devtools_mpsc_chan);
 
             let global = DedicatedWorkerGlobalScope::new(
                 init, url, id, devtools_mpsc_port, runtime.clone(),
@@ -291,14 +291,14 @@ impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalS
     fn receive_event(self) -> Result<MixedMessage, RecvError> {
         let scope = WorkerGlobalScopeCast::from_ref(self);
         let worker_port = &self.receiver;
-        let devtools_port = scope.devtools_port();
+        let devtools_port = scope.from_devtools_receiver();
 
         let sel = Select::new();
         let mut worker_handle = sel.handle(worker_port);
         let mut devtools_handle = sel.handle(devtools_port);
         unsafe {
             worker_handle.add();
-            if scope.devtools_sender().is_some() {
+            if scope.from_devtools_sender().is_some() {
                 devtools_handle.add();
             }
         }

components/script/dom/worker.rs

@@ -104,8 +104,8 @@ impl Worker {
         let init = WorkerGlobalScopeInit {
             resource_task: resource_task,
             mem_profiler_chan: global.mem_profiler_chan(),
-            devtools_chan: global.devtools_chan(),
+            to_devtools_sender: global.devtools_chan(),
-            devtools_sender: optional_sender,
+            from_devtools_sender: optional_sender,
             constellation_chan: constellation_chan,
             worker_id: worker_id,
         };

components/script/dom/workerglobalscope.rs

@@ -45,8 +45,8 @@ pub enum WorkerGlobalScopeTypeId {
 pub struct WorkerGlobalScopeInit {
     pub resource_task: ResourceTask,
     pub mem_profiler_chan: mem::ProfilerChan,
-    pub devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
+    pub to_devtools_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
-    pub devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
+    pub from_devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
     pub constellation_chan: ConstellationChan,
     pub worker_id: WorkerId,
 }
@@ -71,17 +71,17 @@ pub struct WorkerGlobalScope {
     #[ignore_heap_size_of = "Defined in std"]
     mem_profiler_chan: mem::ProfilerChan,
     #[ignore_heap_size_of = "Defined in ipc-channel"]
-    devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
+    to_devtools_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
 
     #[ignore_heap_size_of = "Defined in ipc-channel"]
     /// Optional `IpcSender` for sending the `DevtoolScriptControlMsg`
     /// to the server from within the worker
-    devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
+    from_devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
 
     #[ignore_heap_size_of = "Defined in std"]
     /// This `Receiver` will be ignored later if the corresponding
     /// `IpcSender` doesn't exist
-    devtools_receiver: Receiver<DevtoolScriptControlMsg>,
+    from_devtools_receiver: Receiver<DevtoolScriptControlMsg>,
 
     /// A flag to indicate whether the developer tools has requested live updates
     /// from the worker
@@ -96,7 +96,7 @@ impl WorkerGlobalScope {
                          init: WorkerGlobalScopeInit,
                          worker_url: Url,
                          runtime: Rc<Runtime>,
-                         devtools_receiver: Receiver<DevtoolScriptControlMsg>)
+                         from_devtools_receiver: Receiver<DevtoolScriptControlMsg>)
                          -> WorkerGlobalScope {
         WorkerGlobalScope {
             eventtarget: EventTarget::new_inherited(EventTargetTypeId::WorkerGlobalScope(type_id)),
@@ -111,9 +111,9 @@ impl WorkerGlobalScope {
             crypto: Default::default(),
             timers: TimerManager::new(),
             mem_profiler_chan: init.mem_profiler_chan,
-            devtools_chan: init.devtools_chan,
+            to_devtools_sender: init.to_devtools_sender,
-            devtools_sender: init.devtools_sender,
+            from_devtools_sender: init.from_devtools_sender,
-            devtools_receiver: devtools_receiver,
+            from_devtools_receiver: from_devtools_receiver,
             devtools_wants_updates: Cell::new(false),
             constellation_chan: init.constellation_chan,
         }
@@ -124,15 +124,15 @@ impl WorkerGlobalScope {
     }
 
     pub fn devtools_chan(&self) -> Option<IpcSender<ScriptToDevtoolsControlMsg>> {
-        self.devtools_chan.clone()
+        self.to_devtools_sender.clone()
     }
 
-    pub fn devtools_sender(&self) -> Option<IpcSender<DevtoolScriptControlMsg>> {
+    pub fn from_devtools_sender(&self) -> Option<IpcSender<DevtoolScriptControlMsg>> {
-        self.devtools_sender.clone()
+        self.from_devtools_sender.clone()
     }
 
-    pub fn devtools_port(&self) -> &Receiver<DevtoolScriptControlMsg> {
+    pub fn from_devtools_receiver(&self) -> &Receiver<DevtoolScriptControlMsg> {
-        &self.devtools_receiver
+        &self.from_devtools_receiver
     }
 
     pub fn constellation_chan(&self) -> ConstellationChan {