Pass a String to spawn_named.

IntoString has been removed from Rust, and named() will take a String, so
there is no good reason to do otherwise here.

components/net/file_loader.rs

@@ -5,6 +5,7 @@
 use resource_task::{ProgressMsg, Metadata, LoadData, start_sending, TargetedLoadResponse, ResponseSenders};
 use resource_task::ProgressMsg::{Payload, Done};
 
+use std::borrow::ToOwned;
 use std::io;
 use std::io::File;
 use servo_util::task::spawn_named;
@@ -38,7 +39,7 @@ pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
         eventual_consumer: load_data.consumer,
     };
     let progress_chan = start_sending(senders, Metadata::default(url.clone()));
-    spawn_named("file_loader", proc() {
+    spawn_named("file_loader".to_owned(), proc() {
         let file_path: Result<Path, ()> = url.to_file_path();
         match file_path {
             Ok(file_path) => {

components/net/http_loader.rs

@@ -18,7 +18,7 @@ use url::{Url, UrlParser};
 use std::borrow::ToOwned;
 
 pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
-    spawn_named("http_loader", proc() load(load_data, start_chan))
+    spawn_named("http_loader".to_owned(), proc() load(load_data, start_chan))
 }
 
 fn send_error(url: Url, err: String, senders: ResponseSenders) {

components/net/image_cache_task.rs

@@ -9,6 +9,7 @@ use resource_task::ProgressMsg::{Payload, Done};
 
 use servo_util::task::spawn_named;
 use servo_util::taskpool::TaskPool;
+use std::borrow::ToOwned;
 use std::comm::{channel, Receiver, Sender};
 use std::collections::HashMap;
 use std::collections::hash_map::{Occupied, Vacant};
@@ -85,7 +86,7 @@ impl ImageCacheTask {
         let (chan, port) = channel();
         let chan_clone = chan.clone();
 
-        spawn_named("ImageCacheTask", proc() {
+        spawn_named("ImageCacheTask".to_owned(), proc() {
             let mut cache = ImageCache {
                 resource_task: resource_task,
                 port: port,
@@ -106,7 +107,7 @@ impl ImageCacheTask {
     pub fn new_sync(resource_task: ResourceTask, task_pool: TaskPool) -> ImageCacheTask {
         let (chan, port) = channel();
 
-        spawn_named("ImageCacheTask (sync)", proc() {
+        spawn_named("ImageCacheTask (sync)".to_owned(), proc() {
             let inner_cache = ImageCacheTask::new(resource_task, task_pool);
 
             loop {
@@ -248,7 +249,7 @@ impl ImageCache {
                 let resource_task = self.resource_task.clone();
                 let url_clone = url.clone();
 
-                spawn_named("ImageCacheTask (prefetch)", proc() {
+                spawn_named("ImageCacheTask (prefetch)".to_owned(), proc() {
                     let url = url_clone;
                     debug!("image_cache_task: started fetch for {}", url.serialize());
 
@@ -469,7 +470,7 @@ fn load_image_data(url: Url, resource_task: ResourceTask) -> Result<Vec<u8>, ()>
 pub fn spawn_listener<A: Send>(f: proc(Receiver<A>):Send) -> Sender<A> {
     let (setup_chan, setup_port) = channel();
 
-    spawn_named("ImageCacheTask (listener)", proc() {
+    spawn_named("ImageCacheTask (listener)".to_owned(), proc() {
         let (chan, port) = channel();
         setup_chan.send(chan);
         f(port);

components/net/local_image_cache.rs

@@ -10,6 +10,7 @@ multiple times and thus triggering reflows multiple times.
 
 use image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg};
 
+use std::borrow::ToOwned;
 use std::comm::{Receiver, channel};
 use std::collections::HashMap;
 use std::collections::hash_map::{Occupied, Vacant};
@@ -130,7 +131,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
                 let on_image_available: proc(ImageResponseMsg, NodeAddress):Send =
                     self.on_image_available.as_ref().unwrap().respond();
                 let url = (*url).clone();
-                spawn_named("LocalImageCache", proc() {
+                spawn_named("LocalImageCache".to_owned(), proc() {
                     let (response_chan, response_port) = channel();
                     image_cache_task.send(Msg::WaitForImage(url, response_chan));
                     on_image_available(response_port.recv(), node_address);

components/net/resource_task.rs

@@ -184,7 +184,7 @@ pub type ResourceTask = Sender<ControlMsg>;
 pub fn new_resource_task(user_agent: Option<String>) -> ResourceTask {
     let (setup_chan, setup_port) = channel();
     let sniffer_task = sniffer_task::new_sniffer_task();
-    spawn_named("ResourceManager", proc() {
+    spawn_named("ResourceManager".to_owned(), proc() {
         ResourceManager::new(setup_port, user_agent, sniffer_task).start();
     });
     setup_chan

components/net/storage_task.rs

@@ -2,6 +2,7 @@
  * 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 std::borrow::ToOwned;
 use std::comm::{channel, Receiver, Sender};
 use std::collections::HashMap;
 use std::collections::TreeMap;
@@ -46,7 +47,7 @@ impl StorageTaskFactory for StorageTask {
     /// Create a StorageTask
     fn new() -> StorageTask {
         let (chan, port) = channel();
-        spawn_named("StorageManager", proc() {
+        spawn_named("StorageManager".to_owned(), proc() {
             StorageManager::new(port).start();
         });
         chan