Reorder imports

components/net/blob_loader.rs

@@ -5,13 +5,13 @@
 use crate::filemanager_thread::FileManager;
 use headers_core::HeaderMapExt;
 use headers_ext::{ContentLength, ContentType};
-use http::HeaderMap;
 use http::header::{self, HeaderValue};
+use http::HeaderMap;
 use ipc_channel::ipc;
 use mime::{self, Mime};
-use net_traits::{http_percent_encode, NetworkError};
 use net_traits::blob_url_store::parse_blob_url;
 use net_traits::filemanager_thread::ReadFileProgress;
+use net_traits::{http_percent_encode, NetworkError};
 use servo_url::ServoUrl;
 
 // TODO: Check on GET

components/net/connector.rs

@@ -5,17 +5,17 @@
 use crate::hosts::replace_host;
 use crate::http_loader::Decoder;
 use flate2::read::GzDecoder;
-use hyper::{Body, Client};
 use hyper::body::Payload;
-use hyper::client::HttpConnector as HyperHttpConnector;
 use hyper::client::connect::{Connect, Destination};
+use hyper::client::HttpConnector as HyperHttpConnector;
 use hyper::rt::Future;
+use hyper::{Body, Client};
 use hyper_openssl::HttpsConnector;
 use openssl::ssl::{SslConnector, SslConnectorBuilder, SslMethod, SslOptions};
 use openssl::x509;
 use std::io::{Cursor, Read};
-use tokio::prelude::{Async, Stream};
 use tokio::prelude::future::Executor;
+use tokio::prelude::{Async, Stream};
 
 pub const BUF_SIZE: usize = 32768;
 

components/net/cookie.rs

@@ -7,12 +7,12 @@
 
 use crate::cookie_rs;
 use hyper_serde::{self, Serde};
-use net_traits::CookieSource;
 use net_traits::pub_domains::is_pub_domain;
+use net_traits::CookieSource;
 use servo_url::ServoUrl;
 use std::borrow::ToOwned;
 use std::net::{Ipv4Addr, Ipv6Addr};
-use time::{Tm, now, at, Duration};
+use time::{at, now, Duration, Tm};
 
 /// A stored cookie that wraps the definition in cookie-rs. This is used to implement
 /// various behaviours defined in the spec that rely on an associated request URL,

components/net/cookie_storage.rs

@@ -7,8 +7,8 @@
 
 use crate::cookie::Cookie;
 use crate::cookie_rs;
-use net_traits::CookieSource;
 use net_traits::pub_domains::reg_suffix;
+use net_traits::CookieSource;
 use servo_url::ServoUrl;
 use std::cmp::Ordering;
 use std::collections::HashMap;

components/net/data_loader.rs

@@ -5,8 +5,8 @@
 use base64;
 use mime::Mime;
 use servo_url::ServoUrl;
-use url::Position;
 use url::percent_encoding::percent_decode;
+use url::Position;
 
 pub enum DecodeError {
     InvalidDataUri,

components/net/fetch/methods.rs

@@ -6,7 +6,7 @@ use crate::blob_loader::load_blob_sync;
 use crate::data_loader::decode;
 use crate::fetch::cors_cache::CorsCache;
 use crate::filemanager_thread::FileManager;
-use crate::http_loader::{HttpState, determine_request_referrer, http_fetch};
+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 devtools_traits::DevtoolsControlMsg;
@@ -18,20 +18,20 @@ use hyper::StatusCode;
 use ipc_channel::ipc::IpcReceiver;
 use mime::{self, Mime};
 use mime_guess::guess_mime_type;
-use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy};
 use net_traits::request::{CredentialsMode, Destination, Referrer, Request, RequestMode};
-use net_traits::request::{ResponseTainting, Origin, Window};
+use net_traits::request::{Origin, ResponseTainting, Window};
 use net_traits::response::{Response, ResponseBody, ResponseType};
-use servo_channel::{channel, Sender, Receiver};
+use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy};
+use servo_channel::{channel, Receiver, Sender};
 use servo_url::ServoUrl;
 use std::borrow::Cow;
 use std::fs::File;
-use std::io::{BufReader, BufRead, Seek, SeekFrom};
+use std::io::{BufRead, BufReader, Seek, SeekFrom};
 use std::mem;
 use std::ops::Bound;
 use std::str;
-use std::sync::{Arc, Mutex};
 use std::sync::atomic::Ordering;
+use std::sync::{Arc, Mutex};
 use std::thread;
 
 lazy_static! {

components/net/filemanager_thread.rs

@@ -7,15 +7,17 @@ use ipc_channel::ipc::{self, IpcSender};
 use mime_guess::guess_mime_type_opt;
 use net_traits::blob_url_store::{BlobBuf, BlobURLStoreError};
 use net_traits::filemanager_thread::{FileManagerResult, FileManagerThreadMsg, FileOrigin};
-use net_traits::filemanager_thread::{FileManagerThreadError, ReadFileProgress, RelativePos, SelectedFile};
+use net_traits::filemanager_thread::{
+    FileManagerThreadError, ReadFileProgress, RelativePos, SelectedFile,
+};
 use servo_config::prefs::PREFS;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
 use std::ops::Index;
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, RwLock};
 use std::sync::atomic::{self, AtomicBool, AtomicUsize, Ordering};
+use std::sync::{Arc, RwLock};
 use std::thread;
 use url::Url;
 use uuid::Uuid;

components/net/hsts.rs

@@ -3,8 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use embedder_traits::resources::{self, Resource};
-use net_traits::IncludeSubdomains;
 use net_traits::pub_domains::reg_suffix;
+use net_traits::IncludeSubdomains;
 use serde_json;
 use servo_url::ServoUrl;
 use std::collections::HashMap;

components/net/http_cache.rs

@@ -10,22 +10,24 @@
 use crate::fetch::methods::{Data, DoneChannel};
 use headers_core::HeaderMapExt;
 use headers_ext::{CacheControl, ContentRange, Expires, LastModified, Pragma, Range, Vary};
-use http::{header, HeaderMap};
 use http::header::HeaderValue;
+use http::{header, HeaderMap};
 use hyper::{Method, StatusCode};
-use malloc_size_of::{MallocSizeOf, MallocSizeOfOps, MallocUnconditionalSizeOf, MallocUnconditionalShallowSizeOf};
 use malloc_size_of::Measurable;
-use net_traits::{Metadata, FetchMetadata};
+use malloc_size_of::{
+    MallocSizeOf, MallocSizeOfOps, MallocUnconditionalShallowSizeOf, MallocUnconditionalSizeOf,
+};
 use net_traits::request::Request;
 use net_traits::response::{HttpsState, Response, ResponseBody};
+use net_traits::{FetchMetadata, Metadata};
 use servo_arc::Arc;
-use servo_channel::{Sender, channel};
+use servo_channel::{channel, Sender};
 use servo_config::prefs::PREFS;
 use servo_url::ServoUrl;
 use std::collections::HashMap;
 use std::ops::Bound;
-use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Mutex;
 use std::time::SystemTime;
 use time;
 use time::{Duration, Timespec, Tm};

components/net/http_loader.rs

@@ -4,38 +4,47 @@
 
 use brotli::Decompressor;
 use bytes::Bytes;
-use crate::connector::{BUF_SIZE, Connector, create_http_client, WrappedBody};
+use crate::connector::{create_http_client, Connector, WrappedBody, BUF_SIZE};
 use crate::cookie;
 use crate::cookie_storage::CookieStorage;
 use crate::fetch::cors_cache::CorsCache;
+use crate::fetch::methods::{
+    is_cors_safelisted_method, is_cors_safelisted_request_header, main_fetch,
+};
 use crate::fetch::methods::{Data, DoneChannel, FetchContext, Target};
-use crate::fetch::methods::{is_cors_safelisted_request_header, is_cors_safelisted_method, main_fetch};
 use crate::hsts::HstsList;
 use crate::http_cache::HttpCache;
 use crate::resource_thread::AuthCache;
-use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest};
+use devtools_traits::{
+    ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest,
+};
 use devtools_traits::{HttpResponse as DevtoolsHttpResponse, NetworkEvent};
 use flate2::read::{DeflateDecoder, GzDecoder};
 use headers_core::HeaderMapExt;
 use headers_ext::{AccessControlAllowCredentials, AccessControlAllowHeaders};
-use headers_ext::{AccessControlAllowMethods, AccessControlRequestHeaders, AccessControlRequestMethod, Authorization};
+use headers_ext::{
+    AccessControlAllowMethods, AccessControlRequestHeaders, AccessControlRequestMethod,
+    Authorization,
+};
 use headers_ext::{AccessControlAllowOrigin, AccessControlMaxAge, Basic};
 use headers_ext::{CacheControl, ContentEncoding, ContentLength};
-use headers_ext::{Host, IfModifiedSince, LastModified, Origin as HyperOrigin, Pragma, Referer, UserAgent};
-use http::{HeaderMap, Request as HyperRequest};
+use headers_ext::{
+    Host, IfModifiedSince, LastModified, Origin as HyperOrigin, Pragma, Referer, UserAgent,
+};
 use http::header::{self, HeaderName, HeaderValue};
 use http::uri::Authority;
-use hyper::{Body, Client, Method, StatusCode, Response as HyperResponse};
+use http::{HeaderMap, Request as HyperRequest};
+use hyper::{Body, Client, Method, Response as HyperResponse, StatusCode};
 use hyper_serde::Serde;
 use log;
 use mime;
 use msg::constellation_msg::{HistoryStateId, PipelineId};
-use net_traits::{CookieSource, FetchMetadata, NetworkError, ReferrerPolicy};
 use net_traits::quality::{quality_to_value, Quality, QualityItem};
 use net_traits::request::{CacheMode, CredentialsMode, Destination, Origin};
 use net_traits::request::{RedirectMode, Referrer, Request, RequestMode};
 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};
@@ -50,7 +59,7 @@ use std::sync::Mutex;
 use std::sync::RwLock;
 use std::time::{Duration, SystemTime};
 use time::{self, Tm};
-use tokio::prelude::{Future, future, Stream};
+use tokio::prelude::{future, Future, Stream};
 use tokio::runtime::Runtime;
 use uuid;
 

components/net/image_cache.rs

@@ -4,15 +4,15 @@
 
 use embedder_traits::resources::{self, Resource};
 use immeta::load_from_buf;
-use net_traits::{FetchMetadata, FetchResponseMsg, NetworkError};
-use net_traits::image::base::{Image, ImageMetadata, PixelFormat, load_from_memory};
+use net_traits::image::base::{load_from_memory, Image, ImageMetadata, PixelFormat};
 use net_traits::image_cache::{CanRequestImages, ImageCache, ImageResponder};
 use net_traits::image_cache::{ImageOrMetadataAvailable, ImageResponse, ImageState};
 use net_traits::image_cache::{PendingImageId, UsePlaceholder};
+use net_traits::{FetchMetadata, FetchResponseMsg, NetworkError};
 use pixels;
 use servo_url::ServoUrl;
-use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
+use std::collections::HashMap;
 use std::io;
 use std::mem;
 use std::sync::{Arc, Mutex};

components/net/lib.rs

@@ -76,6 +76,6 @@ pub mod fetch {
 
 /// A module for re-exports of items used in unit tests.
 pub mod test {
+    pub use crate::hosts::{parse_hostsfile, replace_host_table};
     pub use crate::http_loader::HttpState;
-    pub use crate::hosts::{replace_host_table, parse_hostsfile};
 }

components/net/resource_thread.rs

@@ -8,28 +8,28 @@ use crate::cookie;
 use crate::cookie_rs;
 use crate::cookie_storage::CookieStorage;
 use crate::fetch::cors_cache::CorsCache;
-use crate::fetch::methods::{CancellationListener, FetchContext, fetch};
+use crate::fetch::methods::{fetch, CancellationListener, FetchContext};
 use crate::filemanager_thread::FileManager;
 use crate::hsts::HstsList;
 use crate::http_cache::HttpCache;
-use crate::http_loader::{HANDLE, HttpState, http_redirect_fetch};
+use crate::http_loader::{http_redirect_fetch, HttpState, HANDLE};
 use crate::storage_thread::StorageThreadFactory;
 use crate::websocket_loader;
 use devtools_traits::DevtoolsControlMsg;
-use embedder_traits::EmbedderProxy;
 use embedder_traits::resources::{self, Resource};
+use embedder_traits::EmbedderProxy;
 use hyper_serde::Serde;
 use ipc_channel::ipc::{self, IpcReceiver, IpcReceiverSet, IpcSender};
 use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
-use net_traits::{CookieSource, CoreResourceThread};
-use net_traits::{CoreResourceMsg, CustomResponseMediator, FetchChannels};
-use net_traits::{FetchResponseMsg, ResourceThreads, WebSocketDomAction};
-use net_traits::WebSocketNetworkEvent;
 use net_traits::request::{Request, RequestInit};
 use net_traits::response::{Response, ResponseInit};
 use net_traits::storage_thread::StorageThreadMsg;
-use profile_traits::mem::{Report, ReportsChan, ReportKind};
+use net_traits::WebSocketNetworkEvent;
+use net_traits::{CookieSource, CoreResourceThread};
+use net_traits::{CoreResourceMsg, CustomResponseMediator, FetchChannels};
+use net_traits::{FetchResponseMsg, ResourceThreads, WebSocketDomAction};
 use profile_traits::mem::ProfilerChan as MemProfilerChan;
+use profile_traits::mem::{Report, ReportKind, ReportsChan};
 use profile_traits::time::ProfilerChan;
 use serde::{Deserialize, Serialize};
 use serde_json;

components/net/subresource_integrity.rs

@@ -4,7 +4,7 @@
 
 use base64;
 use net_traits::response::{Response, ResponseBody, ResponseType};
-use openssl::hash::{MessageDigest, hash};
+use openssl::hash::{hash, MessageDigest};
 use std::iter::Filter;
 use std::str::Split;
 use std::sync::MutexGuard;

components/net/tests/data_loader.rs

@@ -7,9 +7,9 @@ use headers_core::HeaderMapExt;
 use headers_ext::ContentType;
 use hyper_serde::Serde;
 use mime::{self, Mime};
-use net_traits::{FetchMetadata, FilteredMetadata, NetworkError};
 use net_traits::request::{Origin, Request};
 use net_traits::response::ResponseBody;
+use net_traits::{FetchMetadata, FilteredMetadata, NetworkError};
 use servo_url::ServoUrl;
 use std::ops::Deref;
 

components/net/tests/fetch.rs

@@ -2,21 +2,28 @@
  * 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 crate::{DEFAULT_USER_AGENT, new_fetch_context, create_embedder_proxy, fetch, make_server, make_ssl_server};
 use crate::fetch_with_context;
 use crate::fetch_with_cors_cache;
 use crate::http_loader::{expect_devtools_http_request, expect_devtools_http_response};
+use crate::{
+    create_embedder_proxy, fetch, make_server, make_ssl_server, new_fetch_context,
+    DEFAULT_USER_AGENT,
+};
 use devtools_traits::HttpRequest as DevtoolsHttpRequest;
 use devtools_traits::HttpResponse as DevtoolsHttpResponse;
 use headers_core::HeaderMapExt;
-use headers_ext::{AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowOrigin};
+use headers_ext::{
+    AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowOrigin,
+};
 use headers_ext::{AccessControlAllowMethods, AccessControlMaxAge};
-use headers_ext::{CacheControl, ContentLength, ContentType, Expires, Host, LastModified, Pragma, UserAgent};
-use http::{Method, StatusCode};
+use headers_ext::{
+    CacheControl, ContentLength, ContentType, Expires, Host, LastModified, Pragma, UserAgent,
+};
 use http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use http::uri::Authority;
-use hyper::{Request as HyperRequest, Response as HyperResponse};
+use http::{Method, StatusCode};
 use hyper::body::Body;
+use hyper::{Request as HyperRequest, Response as HyperResponse};
 use mime::{self, Mime};
 use msg::constellation_msg::TEST_PIPELINE_ID;
 use net::connector::create_ssl_connector_builder;
@@ -25,20 +32,20 @@ use net::fetch::methods::{CancellationListener, FetchContext};
 use net::filemanager_thread::FileManager;
 use net::hsts::HstsEntry;
 use net::test::HttpState;
+use net_traits::request::{Destination, Origin, RedirectMode, Referrer, Request, RequestMode};
+use net_traits::response::{CacheState, Response, ResponseBody, ResponseType};
 use net_traits::IncludeSubdomains;
 use net_traits::NetworkError;
 use net_traits::ReferrerPolicy;
-use net_traits::request::{Destination, Origin, RedirectMode, Referrer, Request, RequestMode};
-use net_traits::response::{CacheState, Response, ResponseBody, ResponseType};
 use servo_channel::{channel, Sender};
 use servo_url::{ImmutableOrigin, ServoUrl};
 use std::fs::File;
 use std::io::Read;
 use std::iter::FromIterator;
 use std::path::Path;
-use std::sync::{Arc, Mutex};
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::time::{SystemTime, Duration};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, SystemTime};
 
 // TODO write a struct that impls Handler for storing test values
 

components/net/tests/filemanager_thread.rs

@@ -7,7 +7,9 @@ use embedder_traits::FilterPattern;
 use ipc_channel::ipc;
 use net::filemanager_thread::FileManager;
 use net_traits::blob_url_store::BlobURLStoreError;
-use net_traits::filemanager_thread::{FileManagerThreadMsg, FileManagerThreadError, ReadFileProgress};
+use net_traits::filemanager_thread::{
+    FileManagerThreadError, FileManagerThreadMsg, ReadFileProgress,
+};
 use servo_config::prefs::{PrefValue, PREFS};
 use std::fs::File;
 use std::io::Read;

components/net/tests/http_loader.rs

@@ -7,35 +7,37 @@ use crate::fetch;
 use crate::fetch_with_context;
 use crate::make_server;
 use crate::new_fetch_context;
-use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
 use devtools_traits::HttpRequest as DevtoolsHttpRequest;
 use devtools_traits::HttpResponse as DevtoolsHttpResponse;
-use flate2::Compression;
+use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
 use flate2::write::{DeflateEncoder, GzEncoder};
+use flate2::Compression;
 use futures::{self, Future, Stream};
 use headers_core::HeaderMapExt;
-use headers_ext::{Authorization, Basic, AccessControlAllowOrigin, ContentLength, Date, Host, Origin};
+use headers_ext::{
+    AccessControlAllowOrigin, Authorization, Basic, ContentLength, Date, Host, Origin,
+};
 use headers_ext::{StrictTransportSecurity, UserAgent};
-use http::{Method, StatusCode};
 use http::header::{self, HeaderMap, HeaderValue};
 use http::uri::Authority;
-use hyper::{Request as HyperRequest, Response as HyperResponse};
+use http::{Method, StatusCode};
 use hyper::body::Body;
+use hyper::{Request as HyperRequest, Response as HyperResponse};
 use msg::constellation_msg::TEST_PIPELINE_ID;
 use net::cookie::Cookie;
 use net::cookie_storage::CookieStorage;
 use net::resource_thread::AuthCacheEntry;
 use net::test::replace_host_table;
-use net_traits::{CookieSource, NetworkError};
-use net_traits::request::{Request, RequestInit, RequestMode, CredentialsMode, Destination};
+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::{ServoUrl, ImmutableOrigin};
+use servo_url::{ImmutableOrigin, ServoUrl};
 use std::collections::HashMap;
 use std::io::Write;
 use std::str;
-use std::sync::{Arc, Mutex, RwLock};
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
 use std::time::Duration;
 
 fn mock_origin() -> ImmutableOrigin {

components/net/tests/main.rs

@@ -44,21 +44,21 @@ mod resource_thread;
 mod subresource_integrity;
 
 use devtools_traits::DevtoolsControlMsg;
-use embedder_traits::{EmbedderProxy, EventLoopWaker};
 use embedder_traits::resources::{self, Resource};
+use embedder_traits::{EmbedderProxy, EventLoopWaker};
 use futures::{Future, Stream};
-use hyper::{Body, Request as HyperRequest, Response as HyperResponse};
-use hyper::server::Server as HyperServer;
 use hyper::server::conn::Http;
+use hyper::server::Server as HyperServer;
 use hyper::service::service_fn_ok;
+use hyper::{Body, Request as HyperRequest, Response as HyperResponse};
 use net::connector::create_ssl_connector_builder;
 use net::fetch::cors_cache::CorsCache;
 use net::fetch::methods::{self, CancellationListener, FetchContext};
 use net::filemanager_thread::FileManager;
 use net::test::HttpState;
-use net_traits::FetchTaskTarget;
 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;

components/net/tests/subresource_integrity.rs

@@ -2,7 +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 net::subresource_integrity::{SriEntry, get_prioritized_hash_function, get_strongest_metadata};
+use net::subresource_integrity::{get_prioritized_hash_function, get_strongest_metadata, SriEntry};
 use net::subresource_integrity::{is_response_integrity_valid, parsed_metadata};
 use net_traits::response::{Response, ResponseBody};
 use servo_url::ServoUrl;

components/net/websocket_loader.rs

@@ -12,20 +12,23 @@ use headers_ext::Host;
 use http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use http::uri::Authority;
 use ipc_channel::ipc::{IpcReceiver, IpcSender};
+use net_traits::request::{RequestInit, RequestMode};
 use net_traits::{CookieSource, MessageData};
 use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
-use net_traits::request::{RequestInit, RequestMode};
 use openssl::ssl::SslStream;
 use servo_config::opts;
 use servo_url::ServoUrl;
 use std::fs;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 use std::thread;
 use url::Url;
-use ws::{CloseCode, Factory, Handler, Handshake, Message, Request, Response as WsResponse, Sender, WebSocket};
-use ws::{Error as WebSocketError, ErrorKind as WebSocketErrorKind, Result as WebSocketResult};
 use ws::util::TcpStream;
+use ws::{
+    CloseCode, Factory, Handler, Handshake, Message, Request, Response as WsResponse, Sender,
+    WebSocket,
+};
+use ws::{Error as WebSocketError, ErrorKind as WebSocketErrorKind, Result as WebSocketResult};
 
 /// A client for connecting to a websocket server
 #[derive(Clone)]