Strict import formatting (grouping and granularity) (#30325)

* strict imports formatting

* Reformat all imports

components/net/connector.rs

@@ -2,20 +2,24 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::hosts::replace_host;
-use crate::http_loader::HANDLE;
-use futures::{task::Context, task::Poll, Future};
+use std::collections::hash_map::HashMap;
+use std::convert::TryFrom;
+use std::sync::{Arc, Mutex};
+
+use futures::task::{Context, Poll};
+use futures::Future;
 use http::uri::{Authority, Uri as Destination};
 use hyper::client::HttpConnector as HyperHttpConnector;
 use hyper::rt::Executor;
-use hyper::{service::Service, Body, Client};
+use hyper::service::Service;
+use hyper::{Body, Client};
 use hyper_rustls::HttpsConnector as HyperRustlsHttpsConnector;
 use log::warn;
 use rustls::client::WebPkiVerifier;
 use rustls::{Certificate, ClientConfig, OwnedTrustAnchor, RootCertStore, ServerName};
-use std::collections::hash_map::HashMap;
-use std::convert::TryFrom;
-use std::sync::{Arc, Mutex};
+
+use crate::hosts::replace_host;
+use crate::http_loader::HANDLE;
 
 pub const BUF_SIZE: usize = 32768;
 

components/net/cookie.rs

@@ -5,13 +5,14 @@
 //! Implementation of cookie creation and matching as specified by
 //! http://tools.ietf.org/html/rfc6265
 
+use std::borrow::ToOwned;
+use std::net::{Ipv4Addr, Ipv6Addr};
+
 use hyper_serde::Serde;
 use net_traits::pub_domains::is_pub_domain;
 use net_traits::CookieSource;
 use serde::{Deserialize, Serialize};
 use servo_url::ServoUrl;
-use std::borrow::ToOwned;
-use std::net::{Ipv4Addr, Ipv6Addr};
 use time::{at, now, Duration, Tm};
 
 /// A stored cookie that wraps the definition in cookie-rs. This is used to implement

components/net/cookie_storage.rs

@@ -5,17 +5,19 @@
 //! Implementation of cookie storage as specified in
 //! http://tools.ietf.org/html/rfc6265
 
-use crate::cookie::Cookie;
+use std::cmp::Ordering;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+
 use log::{debug, info};
 use net_traits::pub_domains::reg_suffix;
 use net_traits::CookieSource;
 use serde::{Deserialize, Serialize};
 use servo_url::ServoUrl;
-use std::cmp::Ordering;
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
 use time::{self, Tm};
 
+use crate::cookie::Cookie;
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct CookieStorage {
     version: u32,

components/net/decoder.rs

@@ -27,21 +27,22 @@ The following types directly support the gzip compression case:
 - `Peeked` is a buffer that keeps a few bytes available so `libflate`s `read_exact` calls won't fail
 */
 
-use crate::connector::BUF_SIZE;
-use brotli::Decompressor;
-use bytes::{Buf, BufMut, Bytes, BytesMut};
-use flate2::read::DeflateDecoder;
-use futures::{task::Context, task::Poll, Future, Stream};
-use hyper::header::{HeaderValue, CONTENT_ENCODING, TRANSFER_ENCODING};
-use hyper::{self, Body, Response};
-use libflate::non_blocking::gzip;
-use std::cmp;
-use std::fmt;
 use std::io::{self, Read};
-use std::mem;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 use std::task::Waker;
+use std::{cmp, fmt, mem};
+
+use brotli::Decompressor;
+use bytes::{Buf, BufMut, Bytes, BytesMut};
+use flate2::read::DeflateDecoder;
+use futures::task::{Context, Poll};
+use futures::{Future, Stream};
+use hyper::header::{HeaderValue, CONTENT_ENCODING, TRANSFER_ENCODING};
+use hyper::{self, Body, Response};
+use libflate::non_blocking::gzip;
+
+use crate::connector::BUF_SIZE;
 
 #[derive(Debug)]
 pub enum Error {

components/net/fetch/headers.rs

@@ -2,11 +2,12 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use headers::HeaderMap;
-use net_traits::fetch::headers::get_value_from_header_list;
 use std::iter::Peekable;
 use std::str::Chars;
 
+use headers::HeaderMap;
+use net_traits::fetch::headers::get_value_from_header_list;
+
 /// <https://fetch.spec.whatwg.org/#http-tab-or-space>
 const HTTP_TAB_OR_SPACE: &[char] = &['\u{0009}', '\u{0020}'];
 

components/net/fetch/methods.rs

@@ -2,21 +2,22 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::data_loader::decode;
-use crate::fetch::cors_cache::CorsCache;
-use crate::fetch::headers::determine_nosniff;
-use crate::filemanager_thread::{FileManager, FILE_CHUNK_SIZE};
-use crate::http_loader::{determine_requests_referrer, http_fetch, HttpState};
-use crate::http_loader::{set_default_accept, set_default_accept_language};
-use crate::subresource_integrity::is_response_integrity_valid;
-use base64::{engine::general_purpose, Engine as _};
+use std::borrow::Cow;
+use std::fs::File;
+use std::io::{self, BufReader, Seek, SeekFrom};
+use std::ops::Bound;
+use std::sync::atomic::Ordering;
+use std::sync::{Arc, Mutex};
+use std::{mem, str};
+
+use base64::engine::general_purpose;
+use base64::Engine as _;
 use content_security_policy as csp;
 use crossbeam_channel::Sender;
 use devtools_traits::DevtoolsControlMsg;
 use headers::{AccessControlExposeHeaders, ContentType, HeaderMapExt, Range};
 use http::header::{self, HeaderMap, HeaderName};
-use http::Method;
-use http::StatusCode;
+use http::{Method, StatusCode};
 use ipc_channel::ipc::{self, IpcReceiver};
 use lazy_static::lazy_static;
 use log::{debug, warn};
@@ -24,31 +25,33 @@ use mime::{self, Mime};
 use net_traits::blob_url_store::{parse_blob_url, BlobURLStoreError};
 use net_traits::filemanager_thread::{FileTokenCheck, RelativePos};
 use net_traits::request::{
-    is_cors_safelisted_method, is_cors_safelisted_request_header, Origin, ResponseTainting, Window,
-};
-use net_traits::request::{
-    BodyChunkRequest, BodyChunkResponse, CredentialsMode, Destination, Referrer, Request,
-    RequestMode,
+    is_cors_safelisted_method, is_cors_safelisted_request_header, BodyChunkRequest,
+    BodyChunkResponse, CredentialsMode, Destination, Origin, Referrer, Request, RequestMode,
+    ResponseTainting, Window,
 };
 use net_traits::response::{Response, ResponseBody, ResponseType};
-use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy, ResourceFetchTiming};
-use net_traits::{ResourceAttribute, ResourceTimeValue, ResourceTimingType};
+use net_traits::{
+    FetchTaskTarget, NetworkError, ReferrerPolicy, ResourceAttribute, ResourceFetchTiming,
+    ResourceTimeValue, ResourceTimingType,
+};
 use rustls::Certificate;
 use serde::{Deserialize, Serialize};
 use servo_arc::Arc as ServoArc;
 use servo_url::ServoUrl;
-use std::borrow::Cow;
-use std::fs::File;
-use std::io::{self, BufReader, Seek, SeekFrom};
-use std::mem;
-use std::ops::Bound;
-use std::str;
-use std::sync::atomic::Ordering;
-use std::sync::{Arc, Mutex};
 use tokio::sync::mpsc::{
     unbounded_channel, UnboundedReceiver as TokioReceiver, UnboundedSender as TokioSender,
 };
 
+use crate::data_loader::decode;
+use crate::fetch::cors_cache::CorsCache;
+use crate::fetch::headers::determine_nosniff;
+use crate::filemanager_thread::{FileManager, FILE_CHUNK_SIZE};
+use crate::http_loader::{
+    determine_requests_referrer, http_fetch, set_default_accept, set_default_accept_language,
+    HttpState,
+};
+use crate::subresource_integrity::is_response_integrity_valid;
+
 lazy_static! {
     static ref X_CONTENT_TYPE_OPTIONS: HeaderName =
         HeaderName::from_static("x-content-type-options");

components/net/filemanager_thread.rs

@@ -2,25 +2,6 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::fetch::methods::{CancellationListener, Data, RangeRequestBounds};
-use crate::resource_thread::CoreResourceThreadPool;
-use embedder_traits::{EmbedderMsg, EmbedderProxy, FilterPattern};
-use headers::{ContentLength, ContentType, HeaderMap, HeaderMapExt};
-use http::header::{self, HeaderValue};
-use ipc_channel::ipc::{self, IpcSender};
-use log::warn;
-use mime::{self, Mime};
-use net_traits::blob_url_store::{BlobBuf, BlobURLStoreError};
-use net_traits::filemanager_thread::{
-    FileManagerResult, FileManagerThreadMsg, FileOrigin, FileTokenCheck,
-};
-use net_traits::filemanager_thread::{
-    FileManagerThreadError, ReadFileProgress, RelativePos, SelectedFile,
-};
-use net_traits::http_percent_encode;
-use net_traits::response::{Response, ResponseBody};
-use servo_arc::Arc as ServoArc;
-use servo_config::pref;
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
@@ -29,10 +10,29 @@ use std::ops::Index;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{self, AtomicBool, AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex, RwLock, Weak};
+
+use embedder_traits::{EmbedderMsg, EmbedderProxy, FilterPattern};
+use headers::{ContentLength, ContentType, HeaderMap, HeaderMapExt};
+use http::header::{self, HeaderValue};
+use ipc_channel::ipc::{self, IpcSender};
+use log::warn;
+use mime::{self, Mime};
+use net_traits::blob_url_store::{BlobBuf, BlobURLStoreError};
+use net_traits::filemanager_thread::{
+    FileManagerResult, FileManagerThreadError, FileManagerThreadMsg, FileOrigin, FileTokenCheck,
+    ReadFileProgress, RelativePos, SelectedFile,
+};
+use net_traits::http_percent_encode;
+use net_traits::response::{Response, ResponseBody};
+use servo_arc::Arc as ServoArc;
+use servo_config::pref;
 use tokio::sync::mpsc::UnboundedSender as TokioSender;
 use url::Url;
 use uuid::Uuid;
 
+use crate::fetch::methods::{CancellationListener, Data, RangeRequestBounds};
+use crate::resource_thread::CoreResourceThreadPool;
+
 pub const FILE_CHUNK_SIZE: usize = 32768; //32 KB
 
 /// FileManagerStore's entry

components/net/hosts.rs

@@ -2,7 +2,6 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use lazy_static::lazy_static;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::env;
@@ -11,6 +10,8 @@ use std::io::{BufReader, Read};
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::Mutex;
 
+use lazy_static::lazy_static;
+
 lazy_static! {
     static ref HOST_TABLE: Mutex<Option<HashMap<String, IpAddr>>> = Mutex::new(create_host_table());
 }

components/net/hsts.rs

@@ -2,6 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+use std::collections::HashMap;
+use std::net::{Ipv4Addr, Ipv6Addr};
+
 use embedder_traits::resources::{self, Resource};
 use headers::{HeaderMapExt, StrictTransportSecurity};
 use http::HeaderMap;
@@ -11,8 +14,6 @@ use net_traits::IncludeSubdomains;
 use serde::{Deserialize, Serialize};
 use servo_config::pref;
 use servo_url::{Host, ServoUrl};
-use std::collections::HashMap;
-use std::net::{Ipv4Addr, Ipv6Addr};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct HstsEntry {

components/net/http_cache.rs

@@ -7,16 +7,21 @@
 //! A memory cache implementing the logic specified in <http://tools.ietf.org/html/rfc7234>
 //! and <http://tools.ietf.org/html/rfc7232>.
 
-use crate::fetch::methods::{Data, DoneChannel};
+use std::collections::HashMap;
+use std::ops::Bound;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Mutex;
+use std::time::SystemTime;
+
 use headers::{
     CacheControl, ContentRange, Expires, HeaderMapExt, LastModified, Pragma, Range, Vary,
 };
 use http::header::HeaderValue;
 use http::{header, HeaderMap, Method, StatusCode};
 use log::debug;
-use malloc_size_of::Measurable;
 use malloc_size_of::{
     MallocSizeOf, MallocSizeOfOps, MallocUnconditionalShallowSizeOf, MallocUnconditionalSizeOf,
+    Measurable,
 };
 use malloc_size_of_derive::MallocSizeOf;
 use net_traits::request::Request;
@@ -25,14 +30,11 @@ use net_traits::{FetchMetadata, Metadata, ResourceFetchTiming};
 use servo_arc::Arc;
 use servo_config::pref;
 use servo_url::ServoUrl;
-use std::collections::HashMap;
-use std::ops::Bound;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Mutex;
-use std::time::SystemTime;
 use time::{Duration, Timespec, Tm};
 use tokio::sync::mpsc::{unbounded_channel as unbounded, UnboundedSender as TokioSender};
 
+use crate::fetch::methods::{Data, DoneChannel};
+
 /// The key used to differentiate requests in the cache.
 #[derive(Clone, Eq, Hash, MallocSizeOf, PartialEq)]
 pub struct CacheKey {

components/net/http_loader.rs

@@ -2,35 +2,28 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::connector::{
-    create_http_client, create_tls_config, CACertificates, CertificateErrorOverrideManager,
-    Connector,
-};
-use crate::cookie;
-use crate::cookie_storage::CookieStorage;
-use crate::decoder::Decoder;
-use crate::fetch::cors_cache::CorsCache;
-use crate::fetch::methods::{main_fetch, Data, DoneChannel, FetchContext, Target};
-use crate::hsts::HstsList;
-use crate::http_cache::{CacheKey, HttpCache};
-use crate::resource_thread::AuthCache;
-use async_recursion::async_recursion;
 use core::convert::Infallible;
+use std::collections::{HashMap, HashSet};
+use std::iter::FromIterator;
+use std::mem;
+use std::ops::Deref;
+use std::sync::{Arc as StdArc, Condvar, Mutex, RwLock};
+use std::time::{Duration, SystemTime};
+
+use async_recursion::async_recursion;
 use crossbeam_channel::Sender;
 use devtools_traits::{
     ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest,
+    HttpResponse as DevtoolsHttpResponse, NetworkEvent,
 };
-use devtools_traits::{HttpResponse as DevtoolsHttpResponse, NetworkEvent};
 use futures::{future, StreamExt, TryFutureExt, TryStreamExt};
 use headers::authorization::Basic;
-use headers::{AccessControlAllowCredentials, AccessControlAllowHeaders, HeaderMapExt};
 use headers::{
-    AccessControlAllowMethods, AccessControlRequestHeaders, AccessControlRequestMethod,
-    Authorization,
+    AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowMethods,
+    AccessControlAllowOrigin, AccessControlMaxAge, AccessControlRequestHeaders,
+    AccessControlRequestMethod, Authorization, CacheControl, ContentEncoding, ContentLength,
+    HeaderMapExt, IfModifiedSince, LastModified, Origin as HyperOrigin, Pragma, Referer, UserAgent,
 };
-use headers::{AccessControlAllowOrigin, AccessControlMaxAge};
-use headers::{CacheControl, ContentEncoding, ContentLength};
-use headers::{IfModifiedSince, LastModified, Origin as HyperOrigin, Pragma, Referer, UserAgent};
 use http::header::{
     self, HeaderValue, ACCEPT, CONTENT_ENCODING, CONTENT_LANGUAGE, CONTENT_LOCATION, CONTENT_TYPE,
 };
@@ -48,27 +41,17 @@ use net_traits::quality::{quality_to_value, Quality, QualityItem};
 use net_traits::request::Origin::Origin as SpecificOrigin;
 use net_traits::request::{
     get_cors_unsafe_header_names, is_cors_non_wildcard_request_header_name,
-    is_cors_safelisted_method, is_cors_safelisted_request_header,
+    is_cors_safelisted_method, is_cors_safelisted_request_header, BodyChunkRequest,
+    BodyChunkResponse, CacheMode, CredentialsMode, Destination, Origin, RedirectMode, Referrer,
+    Request, RequestBuilder, RequestMode, ResponseTainting, ServiceWorkersMode,
 };
-use net_traits::request::{
-    BodyChunkRequest, BodyChunkResponse, RedirectMode, Referrer, Request, RequestBuilder,
-    RequestMode,
-};
-use net_traits::request::{CacheMode, CredentialsMode, Destination, Origin};
-use net_traits::request::{ResponseTainting, ServiceWorkersMode};
 use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
-use net_traits::{CookieSource, FetchMetadata, NetworkError, ReferrerPolicy};
 use net_traits::{
-    RedirectEndValue, RedirectStartValue, ResourceAttribute, ResourceFetchTiming, ResourceTimeValue,
+    CookieSource, FetchMetadata, NetworkError, RedirectEndValue, RedirectStartValue,
+    ReferrerPolicy, ResourceAttribute, ResourceFetchTiming, ResourceTimeValue,
 };
 use servo_arc::Arc;
 use servo_url::{ImmutableOrigin, ServoUrl};
-use std::collections::{HashMap, HashSet};
-use std::iter::FromIterator;
-use std::mem;
-use std::ops::Deref;
-use std::sync::{Arc as StdArc, Condvar, Mutex, RwLock};
-use std::time::{Duration, SystemTime};
 use time::{self, Tm};
 use tokio::runtime::Runtime;
 use tokio::sync::mpsc::{
@@ -77,6 +60,19 @@ use tokio::sync::mpsc::{
 };
 use tokio_stream::wrappers::ReceiverStream;
 
+use crate::connector::{
+    create_http_client, create_tls_config, CACertificates, CertificateErrorOverrideManager,
+    Connector,
+};
+use crate::cookie;
+use crate::cookie_storage::CookieStorage;
+use crate::decoder::Decoder;
+use crate::fetch::cors_cache::CorsCache;
+use crate::fetch::methods::{main_fetch, Data, DoneChannel, FetchContext, Target};
+use crate::hsts::HstsList;
+use crate::http_cache::{CacheKey, HttpCache};
+use crate::resource_thread::AuthCache;
+
 lazy_static! {
     pub static ref HANDLE: Mutex<Option<Runtime>> = Mutex::new(Some(Runtime::new().unwrap()));
 }

components/net/image_cache.rs

@@ -2,30 +2,28 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+use std::collections::hash_map::Entry::{Occupied, Vacant};
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use std::{mem, thread};
+
 use embedder_traits::resources::{self, Resource};
 use imsz::imsz_from_reader;
 use ipc_channel::ipc::IpcSender;
 use log::{debug, warn};
 use net_traits::image::base::{load_from_memory, Image, ImageMetadata};
 use net_traits::image_cache::{
-    CorsStatus, ImageCache, ImageCacheResult, ImageResponder, PendingImageResponse,
+    CorsStatus, ImageCache, ImageCacheResult, ImageOrMetadataAvailable, ImageResponder,
+    ImageResponse, PendingImageId, PendingImageResponse, UsePlaceholder,
 };
-use net_traits::image_cache::{ImageOrMetadataAvailable, ImageResponse};
-use net_traits::image_cache::{PendingImageId, UsePlaceholder};
 use net_traits::request::CorsSettings;
 use net_traits::{
     FetchMetadata, FetchResponseMsg, FilteredMetadata, NetworkError, WebrenderIpcSender,
 };
 use pixels::PixelFormat;
 use servo_url::{ImmutableOrigin, ServoUrl};
-use std::collections::hash_map::Entry::{Occupied, Vacant};
-use std::collections::HashMap;
-use std::mem;
-use std::sync::{Arc, Mutex};
-use std::thread;
-use webrender_api::{
-    units::DeviceIntSize, ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat,
-};
+use webrender_api::units::DeviceIntSize;
+use webrender_api::{ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat};
 
 ///
 /// TODO(gw): Remaining work on image cache:

components/net/resource_thread.rs

@@ -4,19 +4,17 @@
 
 //! A thread that takes a URL and streams back the binary data.
 
-use crate::connector::{
-    create_http_client, create_tls_config, CACertificates, CertificateErrorOverrideManager,
-};
-use crate::cookie;
-use crate::cookie_storage::CookieStorage;
-use crate::fetch::cors_cache::CorsCache;
-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::{http_redirect_fetch, HttpState, HANDLE};
-use crate::storage_thread::StorageThreadFactory;
-use crate::websocket_loader;
+use std::borrow::{Cow, ToOwned};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::prelude::*;
+use std::io::{self, BufReader};
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex, RwLock};
+use std::thread;
+use std::time::Duration;
+
 use crossbeam_channel::Sender;
 use devtools_traits::DevtoolsControlMsg;
 use embedder_traits::EmbedderProxy;
@@ -29,30 +27,31 @@ use net_traits::filemanager_thread::FileTokenCheck;
 use net_traits::request::{Destination, RequestBuilder};
 use net_traits::response::{Response, ResponseInit};
 use net_traits::storage_thread::StorageThreadMsg;
-use net_traits::DiscardFetch;
-use net_traits::FetchTaskTarget;
-use net_traits::WebSocketNetworkEvent;
-use net_traits::{CookieSource, CoreResourceMsg, CoreResourceThread};
-use net_traits::{CustomResponseMediator, FetchChannels};
-use net_traits::{ResourceFetchTiming, ResourceTimingType};
-use net_traits::{ResourceThreads, WebSocketDomAction};
-use profile_traits::mem::ProfilerChan as MemProfilerChan;
-use profile_traits::mem::{Report, ReportKind, ReportsChan};
+use net_traits::{
+    CookieSource, CoreResourceMsg, CoreResourceThread, CustomResponseMediator, DiscardFetch,
+    FetchChannels, FetchTaskTarget, ResourceFetchTiming, ResourceThreads, ResourceTimingType,
+    WebSocketDomAction, WebSocketNetworkEvent,
+};
+use profile_traits::mem::{ProfilerChan as MemProfilerChan, Report, ReportKind, ReportsChan};
 use profile_traits::path;
 use profile_traits::time::ProfilerChan;
 use rustls::RootCertStore;
 use serde::{Deserialize, Serialize};
 use servo_arc::Arc as ServoArc;
 use servo_url::{ImmutableOrigin, ServoUrl};
-use std::borrow::{Cow, ToOwned};
-use std::collections::HashMap;
-use std::fs::File;
-use std::io::{self, prelude::*, BufReader};
-use std::ops::Deref;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex, RwLock};
-use std::thread;
-use std::time::Duration;
+
+use crate::connector::{
+    create_http_client, create_tls_config, CACertificates, CertificateErrorOverrideManager,
+};
+use crate::cookie_storage::CookieStorage;
+use crate::fetch::cors_cache::CorsCache;
+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::{http_redirect_fetch, HttpState, HANDLE};
+use crate::storage_thread::StorageThreadFactory;
+use crate::{cookie, websocket_loader};
 
 /// Load a file with CA certificate and produce a RootCertStore with the results.
 fn load_root_cert_store_from_file(file_path: String) -> io::Result<RootCertStore> {

components/net/storage_thread.rs

@@ -2,15 +2,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::resource_thread;
+use std::borrow::ToOwned;
+use std::collections::{BTreeMap, HashMap};
+use std::path::PathBuf;
+use std::thread;
+
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use net_traits::storage_thread::{StorageThreadMsg, StorageType};
 use servo_url::ServoUrl;
-use std::borrow::ToOwned;
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::thread;
+
+use crate::resource_thread;
 
 const QUOTA_SIZE_LIMIT: usize = 5 * 1024 * 1024;
 

components/net/subresource_integrity.rs

@@ -2,13 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+use std::iter::Filter;
+use std::str::Split;
+use std::sync::MutexGuard;
+
 use base64::Engine;
 use generic_array::ArrayLength;
 use net_traits::response::{Response, ResponseBody, ResponseType};
 use sha2::{Digest, Sha256, Sha384, Sha512};
-use std::iter::Filter;
-use std::str::Split;
-use std::sync::MutexGuard;
 
 const SUPPORTED_ALGORITHM: &'static [&'static str] = &["sha256", "sha384", "sha512"];
 pub type StaticCharVec = &'static [char];

components/net/tests/data_loader.rs

@@ -2,7 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::fetch;
+use std::ops::Deref;
+
 use headers::{ContentType, HeaderMapExt};
 use hyper_serde::Serde;
 use mime::{self, Mime};
@@ -10,7 +11,8 @@ use net_traits::request::{Origin, Referrer, Request};
 use net_traits::response::{HttpsState, ResponseBody};
 use net_traits::{FetchMetadata, FilteredMetadata, NetworkError};
 use servo_url::ServoUrl;
-use std::ops::Deref;
+
+use crate::fetch;
 
 #[cfg(test)]
 fn assert_parse(

components/net/tests/fetch.rs

@@ -4,24 +4,23 @@
 
 #![cfg(not(target_os = "windows"))]
 
-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 std::fs;
+use std::iter::FromIterator;
+use std::path::Path;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex, Weak};
+use std::time::{Duration, SystemTime};
+
 use crossbeam_channel::{unbounded, Sender};
-use devtools_traits::HttpRequest as DevtoolsHttpRequest;
-use devtools_traits::HttpResponse as DevtoolsHttpResponse;
-use headers::StrictTransportSecurity;
-use headers::{AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowOrigin};
-use headers::{AccessControlAllowMethods, AccessControlMaxAge, HeaderMapExt};
-use headers::{CacheControl, ContentLength, ContentType, Expires, LastModified, Pragma, UserAgent};
+use devtools_traits::{HttpRequest as DevtoolsHttpRequest, HttpResponse as DevtoolsHttpResponse};
+use headers::{
+    AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowMethods,
+    AccessControlAllowOrigin, AccessControlMaxAge, CacheControl, ContentLength, ContentType,
+    Expires, HeaderMapExt, LastModified, Pragma, StrictTransportSecurity, UserAgent,
+};
 use http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use http::{Method, StatusCode};
-use hyper::Body;
-use hyper::{Request as HyperRequest, Response as HyperResponse};
+use hyper::{Body, Request as HyperRequest, Response as HyperResponse};
 use mime::{self, Mime};
 use msg::constellation_msg::TEST_PIPELINE_ID;
 use net::fetch::cors_cache::CorsCache;
@@ -41,15 +40,15 @@ use net_traits::{
 };
 use servo_arc::Arc as ServoArc;
 use servo_url::{ImmutableOrigin, ServoUrl};
-use std::fs;
-use std::iter::FromIterator;
-use std::path::Path;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex, Weak};
-use std::time::{Duration, SystemTime};
 use tokio_test::block_on;
 use uuid::Uuid;
 
+use crate::http_loader::{expect_devtools_http_request, expect_devtools_http_response};
+use crate::{
+    create_embedder_proxy, fetch, fetch_with_context, fetch_with_cors_cache, make_server,
+    make_ssl_server, new_fetch_context, DEFAULT_USER_AGENT,
+};
+
 // TODO write a struct that impls Handler for storing test values
 
 #[test]

components/net/tests/file_loader.rs

@@ -3,6 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use std::env;
+
 use url::Url;
 
 #[test]

components/net/tests/filemanager_thread.rs

@@ -2,7 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::create_embedder_proxy;
+use std::fs::File;
+use std::io::Read;
+use std::path::PathBuf;
+use std::sync::Arc;
+
 use embedder_traits::FilterPattern;
 use ipc_channel::ipc;
 use net::filemanager_thread::FileManager;
@@ -12,10 +16,8 @@ use net_traits::filemanager_thread::{
     FileManagerThreadError, FileManagerThreadMsg, ReadFileProgress,
 };
 use servo_config::set_pref;
-use std::fs::File;
-use std::io::Read;
-use std::path::PathBuf;
-use std::sync::Arc;
+
+use crate::create_embedder_proxy;
 
 #[test]
 fn test_filemanager() {

components/net/tests/hsts.rs

@@ -2,9 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+use std::collections::HashMap;
+
 use net::hsts::{HstsEntry, HstsList};
 use net_traits::IncludeSubdomains;
-use std::collections::HashMap;
 
 #[test]
 fn test_hsts_entry_is_not_expired_when_it_has_no_timestamp() {

components/net/tests/http_loader.rs

@@ -4,15 +4,19 @@
 
 #![cfg(not(target_os = "windows"))]
 
-use crate::fetch;
-use crate::fetch_with_context;
-use crate::make_server;
-use crate::new_fetch_context;
+use std::collections::HashMap;
+use std::io::Write;
+use std::str;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
+use std::time::Duration;
+
 use cookie_rs::Cookie as CookiePair;
 use crossbeam_channel::{unbounded, Receiver};
-use devtools_traits::HttpRequest as DevtoolsHttpRequest;
-use devtools_traits::HttpResponse as DevtoolsHttpResponse;
-use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
+use devtools_traits::{
+    ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest,
+    HttpResponse as DevtoolsHttpResponse, NetworkEvent,
+};
 use flate2::write::{DeflateEncoder, GzEncoder};
 use flate2::Compression;
 use headers::authorization::Basic;
@@ -22,8 +26,7 @@ use headers::{
 use http::header::{self, HeaderMap, HeaderValue};
 use http::uri::Authority;
 use http::{Method, StatusCode};
-use hyper::Body;
-use hyper::{Request as HyperRequest, Response as HyperResponse};
+use hyper::{Body, Request as HyperRequest, Response as HyperResponse};
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use msg::constellation_msg::TEST_PIPELINE_ID;
@@ -39,12 +42,8 @@ use net_traits::request::{
 use net_traits::response::ResponseBody;
 use net_traits::{CookieSource, NetworkError, ReferrerPolicy};
 use servo_url::{ImmutableOrigin, ServoUrl};
-use std::collections::HashMap;
-use std::io::Write;
-use std::str;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex, RwLock};
-use std::time::Duration;
+
+use crate::{fetch, fetch_with_context, make_server, new_fetch_context};
 
 fn mock_origin() -> ImmutableOrigin {
     ServoUrl::parse("http://servo.org").unwrap().origin()

components/net/tests/main.rs

@@ -19,6 +19,12 @@ mod resource_thread;
 mod subresource_integrity;
 
 use core::convert::Infallible;
+use std::fs::File;
+use std::io::{self, BufReader};
+use std::net::TcpListener as StdTcpListener;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex, Weak};
+
 use crossbeam_channel::{unbounded, Sender};
 use devtools_traits::DevtoolsControlMsg;
 use embedder_traits::{EmbedderProxy, EventLoopWaker};
@@ -42,13 +48,7 @@ use rustls::{self, Certificate, PrivateKey};
 use rustls_pemfile::{certs, pkcs8_private_keys};
 use servo_arc::Arc as ServoArc;
 use servo_url::ServoUrl;
-use std::fs::File;
-use std::io::{self, BufReader};
-use std::net::TcpListener as StdTcpListener;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex, Weak};
-use tokio::net::TcpListener;
-use tokio::net::TcpStream;
+use tokio::net::{TcpListener, TcpStream};
 use tokio::runtime::{Builder, Runtime};
 use tokio_rustls::{self, TlsAcceptor};
 use tokio_stream::wrappers::TcpListenerStream;

components/net/tests/mime_classifier.rs

@@ -2,14 +2,15 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use mime::{self, Mime};
-use net::mime_classifier::{ApacheBugFlag, MimeClassifier, Mp4Matcher, NoSniffFlag};
-use net_traits::LoadContext;
 use std::env;
 use std::fs::File;
 use std::io::{self, Read};
 use std::path::{self, PathBuf};
 
+use mime::{self, Mime};
+use net::mime_classifier::{ApacheBugFlag, MimeClassifier, Mp4Matcher, NoSniffFlag};
+use net_traits::LoadContext;
+
 fn read_file(path: &path::Path) -> io::Result<Vec<u8>> {
     let mut file = File::open(path)?;
     let mut buffer = Vec::new();

components/net/tests/resource_thread.rs

@@ -2,7 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::create_embedder_proxy;
+use std::net::IpAddr;
+
 use ipc_channel::ipc;
 use net::connector::CACertificates;
 use net::resource_thread::new_core_resource_thread;
@@ -10,7 +11,8 @@ use net::test::parse_hostsfile;
 use net_traits::CoreResourceMsg;
 use profile_traits::mem::ProfilerChan as MemProfilerChan;
 use profile_traits::time::ProfilerChan;
-use std::net::IpAddr;
+
+use crate::create_embedder_proxy;
 
 fn ip(s: &str) -> IpAddr {
     s.parse().unwrap()

components/net/tests/subresource_integrity.rs

@@ -2,8 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use net::subresource_integrity::{get_prioritized_hash_function, get_strongest_metadata, SriEntry};
-use net::subresource_integrity::{is_response_integrity_valid, parsed_metadata};
+use net::subresource_integrity::{
+    get_prioritized_hash_function, get_strongest_metadata, is_response_integrity_valid,
+    parsed_metadata, SriEntry,
+};
 use net_traits::response::{Response, ResponseBody};
 use net_traits::{ResourceFetchTiming, ResourceTimingType};
 use servo_url::ServoUrl;

components/net/websocket_loader.rs

@@ -11,11 +11,9 @@
 //! over events from the network and events from the DOM, using async/await to avoid
 //! the need for a dedicated thread per websocket.
 
-use crate::connector::{create_tls_config, CACertificates, TlsConfig};
-use crate::cookie::Cookie;
-use crate::fetch::methods::should_be_blocked_due_to_bad_port;
-use crate::hosts::replace_host;
-use crate::http_loader::HttpState;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
 use async_tungstenite::tokio::{client_async_tls_with_connector_and_config, ConnectStream};
 use async_tungstenite::WebSocketStream;
 use base64::Engine;
@@ -28,23 +26,25 @@ use ipc_channel::router::ROUTER;
 use lazy_static::lazy_static;
 use log::{debug, trace, warn};
 use net_traits::request::{RequestBuilder, RequestMode};
-use net_traits::{CookieSource, MessageData};
-use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
+use net_traits::{CookieSource, MessageData, WebSocketDomAction, WebSocketNetworkEvent};
 use servo_url::ServoUrl;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
 use tokio::net::TcpStream;
 use tokio::runtime::Runtime;
 use tokio::select;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
 use tokio_rustls::TlsConnector;
-use tungstenite::error::Result as WebSocketResult;
-use tungstenite::error::{Error, ProtocolError, UrlError};
+use tungstenite::error::{Error, ProtocolError, Result as WebSocketResult, UrlError};
 use tungstenite::handshake::client::{Request, Response};
 use tungstenite::protocol::CloseFrame;
 use tungstenite::Message;
 use url::Url;
 
+use crate::connector::{create_tls_config, CACertificates, TlsConfig};
+use crate::cookie::Cookie;
+use crate::fetch::methods::should_be_blocked_due_to_bad_port;
+use crate::hosts::replace_host;
+use crate::http_loader::HttpState;
+
 // Websockets get their own tokio runtime that's independent of the one used for
 // HTTP connections, otherwise a large number of websockets could occupy all workers
 // and starve other network traffic.