diff --git a/components/net/fetch/methods.rs b/components/net/fetch/methods.rs
index f6a6c62f489..adff11d425b 100644
--- a/components/net/fetch/methods.rs
+++ b/components/net/fetch/methods.rs
@@ -28,7 +28,6 @@ use net_traits::request::{CacheMode, CredentialsMode, Destination};
 use net_traits::request::{RedirectMode, Referrer, Request, RequestMode, ResponseTainting};
 use net_traits::request::{Type, Origin, Window};
 use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
-use resource_thread::CancellationListener;
 use servo_url::ServoUrl;
 use std::borrow::Cow;
 use std::collections::HashSet;
@@ -992,7 +991,6 @@ fn http_network_fetch(request: Rc<Request>,
         connector: connection,
     };
     let url = request.current_url();
-    let cancellation_listener = CancellationListener::new(None);
 
     let request_id = context.devtools_chan.as_ref().map(|_| {
         uuid::Uuid::new_v4().simple().to_string()
@@ -1004,7 +1002,7 @@ fn http_network_fetch(request: Rc<Request>,
     let is_xhr = request.destination == Destination::None;
     let wrapped_response = obtain_response(&factory, &url, &request.method.borrow(),
                                            &request.headers.borrow(),
-                                           &cancellation_listener, &request.body.borrow(), &request.method.borrow(),
+                                           &request.body.borrow(), &request.method.borrow(),
                                            &request.pipeline_id.get(), request.redirect_count.get() + 1,
                                            request_id.as_ref().map(Deref::deref), is_xhr);
 
@@ -1015,7 +1013,6 @@ fn http_network_fetch(request: Rc<Request>,
             let error = match error.error {
                 LoadErrorType::ConnectionAborted { .. } => unreachable!(),
                 LoadErrorType::Ssl { reason } => NetworkError::SslValidation(error.url, reason),
-                LoadErrorType::Cancelled => NetworkError::LoadCancelled,
                 e => NetworkError::Internal(e.description().to_owned())
             };
             return Response::network_error(error);
diff --git a/components/net/http_loader.rs b/components/net/http_loader.rs
index 69dcf1dddcd..1d10f684a90 100644
--- a/components/net/http_loader.rs
+++ b/components/net/http_loader.rs
@@ -27,7 +27,7 @@ use net_traits::{CookieSource, Metadata, ReferrerPolicy};
 use net_traits::hosts::replace_hosts;
 use openssl;
 use openssl::ssl::error::{OpensslError, SslError};
-use resource_thread::{AuthCache, CancellationListener};
+use resource_thread::AuthCache;
 use servo_url::ServoUrl;
 use std::error::Error;
 use std::fmt;
@@ -240,7 +240,6 @@ impl LoadError {
 
 #[derive(Eq, PartialEq, Debug)]
 pub enum LoadErrorType {
-    Cancelled,
     Connection { reason: String },
     ConnectionAborted { reason: String },
     Decoding { reason: String },
@@ -256,7 +255,6 @@ impl fmt::Display for LoadErrorType {
 impl Error for LoadErrorType {
     fn description(&self) -> &str {
         match *self {
-            LoadErrorType::Cancelled => "load cancelled",
             LoadErrorType::Connection { ref reason } => reason,
             LoadErrorType::ConnectionAborted { ref reason } => reason,
             LoadErrorType::Decoding { ref reason } => reason,
@@ -511,7 +509,6 @@ pub fn obtain_response<A>(request_factory: &HttpRequestFactory<R=A>,
                           url: &ServoUrl,
                           method: &Method,
                           request_headers: &Headers,
-                          cancel_listener: &CancellationListener,
                           data: &Option<Vec<u8>>,
                           load_data_method: &Method,
                           pipeline_id: &Option<PipelineId>,
@@ -569,10 +566,6 @@ pub fn obtain_response<A>(request_factory: &HttpRequestFactory<R=A>,
 
         let connect_end = precise_time_ms();
 
-        if cancel_listener.is_cancelled() {
-            return Err(LoadError::new(connection_url.clone(), LoadErrorType::Cancelled));
-        }
-
         let send_start = precise_time_ms();
 
         let maybe_response = req.send(request_body);