Update crossbeam-channel to 0.3

components/net/Cargo.toml

@@ -20,6 +20,7 @@ base64 = "0.9"
 brotli = "2.5"
 bytes = "0.4"
 cookie_rs = {package = "cookie", version = "0.11"}
+crossbeam-channel = "0.3"
 devtools_traits = {path = "../devtools_traits"}
 embedder_traits = { path = "../embedder_traits" }
 flate2 = "1"
@@ -47,7 +48,6 @@ serde = "1.0"
 serde_json = "1.0"
 servo_allocator = {path = "../allocator"}
 servo_arc = {path = "../servo_arc"}
-servo_channel = {path = "../channel"}
 servo_config = {path = "../config"}
 servo_url = {path = "../url"}
 tokio = "0.1"

components/net/fetch/methods.rs

@@ -9,6 +9,7 @@ use crate::filemanager_thread::FileManager;
 use crate::http_loader::{determine_request_referrer, http_fetch, HttpState};
 use crate::http_loader::{set_default_accept, set_default_accept_language};
 use crate::subresource_integrity::is_response_integrity_valid;
+use crossbeam_channel::{unbounded, Receiver, Sender};
 use devtools_traits::DevtoolsControlMsg;
 use headers_core::HeaderMapExt;
 use headers_ext::{AccessControlExposeHeaders, ContentType, Range};
@@ -22,7 +23,6 @@ use net_traits::request::{CredentialsMode, Destination, Referrer, Request, Reque
 use net_traits::request::{Origin, ResponseTainting, Window};
 use net_traits::response::{Response, ResponseBody, ResponseType};
 use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy};
-use servo_channel::{channel, Receiver, Sender};
 use servo_url::ServoUrl;
 use std::borrow::Cow;
 use std::fs::File;
@@ -540,7 +540,7 @@ fn scheme_fetch(
                     let mut response = Response::new(url);
                     response.headers.typed_insert(ContentType::from(mime));
 
-                    let (done_sender, done_receiver) = channel();
+                    let (done_sender, done_receiver) = unbounded();
                     *done_chan = Some((done_sender.clone(), done_receiver));
                     *response.body.lock().unwrap() = ResponseBody::Receiving(vec![]);
 

components/net/http_cache.rs

@@ -8,6 +8,7 @@
 //! and <http://tools.ietf.org/html/rfc7232>.
 
 use crate::fetch::methods::{Data, DoneChannel};
+use crossbeam_channel::{unbounded, Sender};
 use headers_core::HeaderMapExt;
 use headers_ext::{CacheControl, ContentRange, Expires, LastModified, Pragma, Range, Vary};
 use http::header::HeaderValue;
@@ -21,7 +22,6 @@ use net_traits::request::Request;
 use net_traits::response::{HttpsState, Response, ResponseBody};
 use net_traits::{FetchMetadata, Metadata};
 use servo_arc::Arc;
-use servo_channel::{channel, Sender};
 use servo_config::prefs::PREFS;
 use servo_url::ServoUrl;
 use std::collections::HashMap;
@@ -306,7 +306,7 @@ fn create_cached_response(
     response.headers = cached_headers.clone();
     response.body = cached_resource.body.clone();
     if let ResponseBody::Receiving(_) = *cached_resource.body.lock().unwrap() {
-        let (done_sender, done_receiver) = channel();
+        let (done_sender, done_receiver) = unbounded();
         *done_chan = Some((done_sender.clone(), done_receiver));
         cached_resource
             .awaiting_body
@@ -670,7 +670,7 @@ impl HttpCache {
                 // Otherwise, create a new dedicated channel to update the consumer.
                 // The response constructed here will replace the 304 one from the network.
                 let in_progress_channel = match *cached_resource.body.lock().unwrap() {
-                    ResponseBody::Receiving(..) => Some(channel()),
+                    ResponseBody::Receiving(..) => Some(unbounded()),
                     ResponseBody::Empty | ResponseBody::Done(..) => None,
                 };
                 match in_progress_channel {

components/net/http_loader.rs

@@ -15,6 +15,7 @@ use crate::fetch::methods::{Data, DoneChannel, FetchContext, Target};
 use crate::hsts::HstsList;
 use crate::http_cache::HttpCache;
 use crate::resource_thread::AuthCache;
+use crossbeam_channel::{unbounded, Sender};
 use devtools_traits::{
     ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest,
 };
@@ -44,7 +45,6 @@ use net_traits::request::{ResponseTainting, ServiceWorkersMode};
 use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
 use net_traits::{CookieSource, FetchMetadata, NetworkError, ReferrerPolicy};
 use openssl::ssl::SslConnectorBuilder;
-use servo_channel::{channel, Sender};
 use servo_url::{ImmutableOrigin, ServoUrl};
 use std::collections::{HashMap, HashSet};
 use std::error::Error;
@@ -1215,7 +1215,7 @@ fn http_network_fetch(
     let res_body = response.body.clone();
 
     // We're about to spawn a future to be waited on here
-    let (done_sender, done_receiver) = channel();
+    let (done_sender, done_receiver) = unbounded();
     *done_chan = Some((done_sender.clone(), done_receiver));
     let meta = match response
         .metadata()

components/net/resource_thread.rs

@@ -15,6 +15,7 @@ use crate::http_cache::HttpCache;
 use crate::http_loader::{http_redirect_fetch, HttpState, HANDLE};
 use crate::storage_thread::StorageThreadFactory;
 use crate::websocket_loader;
+use crossbeam_channel::Sender;
 use devtools_traits::DevtoolsControlMsg;
 use embedder_traits::resources::{self, Resource};
 use embedder_traits::EmbedderProxy;
@@ -32,7 +33,6 @@ use profile_traits::mem::ProfilerChan as MemProfilerChan;
 use profile_traits::mem::{Report, ReportKind, ReportsChan};
 use profile_traits::time::ProfilerChan;
 use serde::{Deserialize, Serialize};
-use servo_channel::Sender;
 use servo_config::opts;
 use servo_url::ServoUrl;
 use std::borrow::{Cow, ToOwned};

components/net/tests/fetch.rs

@@ -9,6 +9,7 @@ use crate::{
     create_embedder_proxy, fetch, make_server, make_ssl_server, new_fetch_context,
     DEFAULT_USER_AGENT,
 };
+use crossbeam_channel::{unbounded, Sender};
 use devtools_traits::HttpRequest as DevtoolsHttpRequest;
 use devtools_traits::HttpResponse as DevtoolsHttpResponse;
 use headers_core::HeaderMapExt;
@@ -37,7 +38,6 @@ use net_traits::response::{CacheState, Response, ResponseBody, ResponseType};
 use net_traits::IncludeSubdomains;
 use net_traits::NetworkError;
 use net_traits::ReferrerPolicy;
-use servo_channel::{channel, Sender};
 use servo_url::{ImmutableOrigin, ServoUrl};
 use std::fs::File;
 use std::io::Read;
@@ -891,7 +891,7 @@ fn test_fetch_redirect_updates_method_runner(
 
 #[test]
 fn test_fetch_redirect_updates_method() {
-    let (tx, rx) = channel();
+    let (tx, rx) = unbounded();
 
     test_fetch_redirect_updates_method_runner(
         tx.clone(),
@@ -901,17 +901,17 @@ fn test_fetch_redirect_updates_method() {
     assert_eq!(rx.recv().unwrap(), true);
     assert_eq!(rx.recv().unwrap(), true);
     // make sure the test doesn't send more data than expected
-    assert_eq!(rx.try_recv().is_none(), true);
+    assert_eq!(rx.try_recv().is_err(), true);
 
     test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::FOUND, Method::POST);
     assert_eq!(rx.recv().unwrap(), true);
     assert_eq!(rx.recv().unwrap(), true);
-    assert_eq!(rx.try_recv().is_none(), true);
+    assert_eq!(rx.try_recv().is_err(), true);
 
     test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::SEE_OTHER, Method::GET);
     assert_eq!(rx.recv().unwrap(), true);
     assert_eq!(rx.recv().unwrap(), true);
-    assert_eq!(rx.try_recv().is_none(), true);
+    assert_eq!(rx.try_recv().is_err(), true);
 
     let extension = Method::from_bytes(b"FOO").unwrap();
 
@@ -923,18 +923,18 @@ fn test_fetch_redirect_updates_method() {
     assert_eq!(rx.recv().unwrap(), true);
     // for MovedPermanently and Found, Method should only be changed if it was Post
     assert_eq!(rx.recv().unwrap(), false);
-    assert_eq!(rx.try_recv().is_none(), true);
+    assert_eq!(rx.try_recv().is_err(), true);
 
     test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::FOUND, extension.clone());
     assert_eq!(rx.recv().unwrap(), true);
     assert_eq!(rx.recv().unwrap(), false);
-    assert_eq!(rx.try_recv().is_none(), true);
+    assert_eq!(rx.try_recv().is_err(), true);
 
     test_fetch_redirect_updates_method_runner(tx.clone(), StatusCode::SEE_OTHER, extension.clone());
     assert_eq!(rx.recv().unwrap(), true);
     // for SeeOther, Method should always be changed, so this should be true
     assert_eq!(rx.recv().unwrap(), true);
-    assert_eq!(rx.try_recv().is_none(), true);
+    assert_eq!(rx.try_recv().is_err(), true);
 }
 
 fn response_is_done(response: &Response) -> bool {
@@ -1044,7 +1044,7 @@ fn test_fetch_with_devtools() {
     let mut request = Request::new(url.clone(), Some(origin), Some(TEST_PIPELINE_ID));
     request.referrer = Referrer::NoReferrer;
 
-    let (devtools_chan, devtools_port) = channel();
+    let (devtools_chan, devtools_port) = unbounded();
 
     let _ = fetch(&mut request, Some(devtools_chan));
     let _ = server.close();

components/net/tests/http_loader.rs

@@ -7,6 +7,7 @@ use crate::fetch;
 use crate::fetch_with_context;
 use crate::make_server;
 use crate::new_fetch_context;
+use crossbeam_channel::{unbounded, Receiver};
 use devtools_traits::HttpRequest as DevtoolsHttpRequest;
 use devtools_traits::HttpResponse as DevtoolsHttpResponse;
 use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
@@ -31,7 +32,6 @@ use net::test::replace_host_table;
 use net_traits::request::{CredentialsMode, Destination, Request, RequestInit, RequestMode};
 use net_traits::response::ResponseBody;
 use net_traits::{CookieSource, NetworkError};
-use servo_channel::{channel, Receiver};
 use servo_url::{ImmutableOrigin, ServoUrl};
 use std::collections::HashMap;
 use std::io::Write;
@@ -243,7 +243,7 @@ fn test_request_and_response_data_with_network_messages() {
         pipeline_id: Some(TEST_PIPELINE_ID),
         ..RequestInit::default()
     });
-    let (devtools_chan, devtools_port) = channel();
+    let (devtools_chan, devtools_port) = unbounded();
     let response = fetch(&mut request, Some(devtools_chan));
     assert!(
         response
@@ -344,7 +344,7 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
         pipeline_id: None,
         ..RequestInit::default()
     });
-    let (devtools_chan, devtools_port) = channel();
+    let (devtools_chan, devtools_port) = unbounded();
     let response = fetch(&mut request, Some(devtools_chan));
     assert!(
         response
@@ -359,7 +359,7 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
     let _ = server.close();
 
     // notification received from devtools
-    assert!(devtools_port.try_recv().is_none());
+    assert!(devtools_port.try_recv().is_err());
 }
 
 #[test]
@@ -388,7 +388,7 @@ fn test_redirected_request_to_devtools() {
         pipeline_id: Some(TEST_PIPELINE_ID),
         ..RequestInit::default()
     });
-    let (devtools_chan, devtools_port) = channel();
+    let (devtools_chan, devtools_port) = unbounded();
     fetch(&mut request, Some(devtools_chan));
 
     let _ = pre_server.close();

components/net/tests/main.rs

@@ -19,6 +19,7 @@ mod mime_classifier;
 mod resource_thread;
 mod subresource_integrity;
 
+use crossbeam_channel::{unbounded, Sender};
 use devtools_traits::DevtoolsControlMsg;
 use embedder_traits::resources::{self, Resource};
 use embedder_traits::{EmbedderProxy, EventLoopWaker};
@@ -36,7 +37,6 @@ use net_traits::request::Request;
 use net_traits::response::Response;
 use net_traits::FetchTaskTarget;
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
-use servo_channel::{channel, Sender};
 use servo_url::ServoUrl;
 use std::net::TcpListener as StdTcpListener;
 use std::path::PathBuf;
@@ -56,7 +56,7 @@ struct FetchResponseCollector {
 }
 
 fn create_embedder_proxy() -> EmbedderProxy {
-    let (sender, _) = channel();
+    let (sender, _) = unbounded();
     let event_loop_waker = || {
         struct DummyEventLoopWaker {}
         impl DummyEventLoopWaker {
@@ -111,7 +111,7 @@ fn fetch(request: &mut Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Respo
 }
 
 fn fetch_with_context(request: &mut Request, context: &FetchContext) -> Response {
-    let (sender, receiver) = channel();
+    let (sender, receiver) = unbounded();
     let mut target = FetchResponseCollector { sender: sender };
 
     methods::fetch(request, &mut target, context);
@@ -120,7 +120,7 @@ fn fetch_with_context(request: &mut Request, context: &FetchContext) -> Response
 }
 
 fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Response {
-    let (sender, receiver) = channel();
+    let (sender, receiver) = unbounded();
     let mut target = FetchResponseCollector { sender: sender };
 
     methods::fetch_with_cors_cache(request, cache, &mut target, &new_fetch_context(None, None));