Merge request type and destination

components/constellation/network_listener.rs

@@ -13,7 +13,7 @@ use msg::constellation_msg::PipelineId;
 use net::http_loader::{set_default_accept, set_default_accept_language};
 use net_traits::{CoreResourceMsg, FetchMetadata, FetchResponseMsg};
 use net_traits::{IpcSend, NetworkError, ResourceThreads};
-use net_traits::request::{Destination, RequestInit, Type};
+use net_traits::request::{Destination, RequestInit};
 use net_traits::response::ResponseInit;
 use std::sync::mpsc::Sender;
 
@@ -59,7 +59,7 @@ impl NetworkListener {
                                    res_init_.clone(),
                                    ipc_sender),
             None => {
-                set_default_accept(Type::None, Destination::Document, &mut listener.req_init.headers);
+                set_default_accept(Destination::Document, &mut listener.req_init.headers);
                 set_default_accept_language(&mut listener.req_init.headers);
 
                 CoreResourceMsg::Fetch(

components/gfx/font_cache_thread.rs

@@ -7,7 +7,7 @@ use font_template::{FontTemplate, FontTemplateDescriptor};
 use fontsan;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use net_traits::{CoreResourceThread, FetchResponseMsg, fetch_async};
-use net_traits::request::{Destination, RequestInit, Type as RequestType};
+use net_traits::request::{Destination, RequestInit};
 use platform::font_context::FontContextHandle;
 use platform::font_list::SANS_SERIF_FONT_FAMILY;
 use platform::font_list::for_each_available_family;
@@ -237,7 +237,6 @@ impl FontCache {
 
                 let request = RequestInit {
                     url: url.clone(),
-                    type_: RequestType::Font,
                     destination: Destination::Font,
                     // TODO: Add a proper origin - Can't import GlobalScope from gfx
                     // We can leave origin to be set by default

components/net/fetch/methods.rs

@@ -17,8 +17,8 @@ use hyper::mime::{Mime, SubLevel, TopLevel};
 use hyper::status::StatusCode;
 use mime_guess::guess_mime_type;
 use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy};
-use net_traits::request::{CredentialsMode, Referrer, Request, RequestMode, ResponseTainting};
+use net_traits::request::{CredentialsMode, Destination, Referrer, Request, RequestMode};
-use net_traits::request::{Type, Origin, Window};
+use net_traits::request::{ResponseTainting, Origin, Window};
 use net_traits::response::{Response, ResponseBody, ResponseType};
 use servo_url::ServoUrl;
 use std::ascii::AsciiExt;
@@ -73,7 +73,7 @@ pub fn fetch_with_cors_cache(request: &mut Request,
     }
 
     // Step 3.
-    set_default_accept(request.type_, request.destination, &mut request.headers);
+    set_default_accept(request.destination, &mut request.headers);
 
     // Step 4.
     set_default_accept_language(&mut request.headers);
@@ -266,9 +266,9 @@ pub fn main_fetch(request: &mut Request,
         // Tests for steps 17 and 18, before step 15 for borrowing concerns.
         let response_is_network_error = response.is_network_error();
         let should_replace_with_nosniff_error =
-            !response_is_network_error && should_be_blocked_due_to_nosniff(request.type_, &response.headers);
+            !response_is_network_error && should_be_blocked_due_to_nosniff(request.destination, &response.headers);
         let should_replace_with_mime_type_error =
-            !response_is_network_error && should_be_blocked_due_to_mime_type(request.type_, &response.headers);
+            !response_is_network_error && should_be_blocked_due_to_mime_type(request.destination, &response.headers);
 
         // Step 15.
         let mut network_error_response = response.get_network_error().cloned().map(Response::network_error);
@@ -529,7 +529,7 @@ fn is_null_body_status(status: &Option<StatusCode>) -> bool {
 }
 
 /// <https://fetch.spec.whatwg.org/#should-response-to-request-be-blocked-due-to-nosniff?>
-pub fn should_be_blocked_due_to_nosniff(request_type: Type, response_headers: &Headers) -> bool {
+pub fn should_be_blocked_due_to_nosniff(destination: Destination, response_headers: &Headers) -> bool {
     /// <https://fetch.spec.whatwg.org/#x-content-type-options-header>
     /// This is needed to parse `X-Content-Type-Options` according to spec,
     /// which requires that we inspect only the first value.
@@ -599,37 +599,37 @@ pub fn should_be_blocked_due_to_nosniff(request_type: Type, response_headers: &H
     }
 
     // Assumes str::starts_with is equivalent to mime::TopLevel
-    return match request_type {
+    match content_type_header {
         // Step 6
-        Type::Script => {
+        Some(&ContentType(ref mime_type)) if destination.is_script_like()
-            match content_type_header {
+            => !is_javascript_mime_type(mime_type),
-                Some(&ContentType(ref mime_type)) => !is_javascript_mime_type(&mime_type),
+
-                None => true
-            }
-        }
         // Step 7
-        Type::Style => {
+        Some(&ContentType(Mime(ref tl, ref sl, _))) if destination == Destination::Style
-            match content_type_header {
+            => *tl != TopLevel::Text && *sl != SubLevel::Css,
-                Some(&ContentType(Mime(TopLevel::Text, SubLevel::Css, _))) => false,
+
-                _ => true
+        None if destination == Destination::Style || destination.is_script_like() => true,
-            }
-        }
         // Step 8
         _ => false
-    };
+    }
 }
 
 /// <https://fetch.spec.whatwg.org/#should-response-to-request-be-blocked-due-to-mime-type?>
-fn should_be_blocked_due_to_mime_type(request_type: Type, response_headers: &Headers) -> bool {
+fn should_be_blocked_due_to_mime_type(destination: Destination, response_headers: &Headers) -> bool {
+    // Step 1
     let mime_type = match response_headers.get::<ContentType>() {
         Some(header) => header,
         None => return false,
     };
-    request_type == Type::Script && match *mime_type {
+
+    // Step 2-3
+    destination.is_script_like() && match *mime_type {
         ContentType(Mime(TopLevel::Audio, _, _)) |
         ContentType(Mime(TopLevel::Video, _, _)) |
         ContentType(Mime(TopLevel::Image, _, _)) => true,
         ContentType(Mime(TopLevel::Text, SubLevel::Ext(ref ext), _)) => ext == "csv",
+
+        // Step 4
         _ => false,
     }
 }

components/net/http_loader.rs

@@ -35,7 +35,7 @@ use msg::constellation_msg::PipelineId;
 use net_traits::{CookieSource, FetchMetadata, NetworkError, ReferrerPolicy};
 use net_traits::request::{CacheMode, CredentialsMode, Destination, Origin};
 use net_traits::request::{RedirectMode, Referrer, Request, RequestMode};
-use net_traits::request::{ResponseTainting, ServiceWorkersMode, Type};
+use net_traits::request::{ResponseTainting, ServiceWorkersMode};
 use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
 use resource_thread::AuthCache;
 use servo_url::{ImmutableOrigin, ServoUrl};
@@ -125,13 +125,13 @@ impl WrappedHttpResponse {
 }
 
 // Step 3 of https://fetch.spec.whatwg.org/#concept-fetch.
-pub fn set_default_accept(type_: Type, destination: Destination, headers: &mut Headers) {
+pub fn set_default_accept(destination: Destination, headers: &mut Headers) {
     if headers.has::<Accept>() {
         return;
     }
-    let value = match (type_, destination) {
+    let value = match destination {
         // Step 3.2.
-        (_, Destination::Document) => {
+        Destination::Document => {
             vec![
                 qitem(mime!(Text / Html)),
                 qitem(mime!(Application / ("xhtml+xml"))),
@@ -140,7 +140,7 @@ pub fn set_default_accept(type_: Type, destination: Destination, headers: &mut H
             ]
         },
         // Step 3.3.
-        (Type::Image, _) => {
+        Destination::Image => {
             vec![
                 qitem(mime!(Image / Png)),
                 qitem(mime!(Image / ("svg+xml") )),
@@ -149,7 +149,7 @@ pub fn set_default_accept(type_: Type, destination: Destination, headers: &mut H
             ]
         },
         // Step 3.3.
-        (Type::Style, _) => {
+        Destination::Style => {
             vec![
                 qitem(mime!(Text / Css)),
                 QualityItem::new(mime!(_ / _), q(0.1))
@@ -1204,7 +1204,6 @@ fn cors_preflight_fetch(request: &Request,
     let mut preflight = Request::new(request.current_url(), Some(request.origin.clone()), request.pipeline_id);
     preflight.method = Method::Options;
     preflight.initiator = request.initiator.clone();
-    preflight.type_ = request.type_.clone();
     preflight.destination = request.destination.clone();
     preflight.origin = request.origin.clone();
     preflight.referrer = request.referrer.clone();

components/net/websocket_loader.rs

@@ -17,7 +17,7 @@ use hyper::status::StatusCode;
 use hyper::version::HttpVersion;
 use net_traits::{CookieSource, MessageData, NetworkError, WebSocketCommunicate, WebSocketConnectData};
 use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
-use net_traits::request::{Destination, Type};
+use net_traits::request::Destination;
 use servo_url::ServoUrl;
 use std::ascii::AsciiExt;
 use std::io::{self, Write};
@@ -280,7 +280,7 @@ fn fetch(url: ServoUrl,
     // TODO: handle request's origin.
 
     // Step 3.
-    set_default_accept(Type::None, Destination::None, &mut headers);
+    set_default_accept(Destination::None, &mut headers);
 
     // Step 4.
     set_default_accept_language(&mut headers);
@@ -370,7 +370,7 @@ fn main_fetch(url: ServoUrl,
         // TODO: handle blocking as mixed content.
         // TODO: handle blocking by content security policy.
         // Not applicable: blocking due to MIME type matters only for scripts.
-        if should_be_blocked_due_to_nosniff(Type::None, &headers) {
+        if should_be_blocked_due_to_nosniff(Destination::None, &headers) {
             response = Err(NetworkError::Internal("Request should be blocked due to nosniff.".into()));
         }
     }

components/net_traits/request.rs

@@ -19,37 +19,37 @@ pub enum Initiator {
     XSLT,
 }
 
-/// A request [type](https://fetch.spec.whatwg.org/#concept-request-type)
-#[derive(Clone, Copy, Deserialize, MallocSizeOf, PartialEq, Serialize)]
-pub enum Type {
-    None,
-    Audio,
-    Font,
-    Image,
-    Script,
-    Style,
-    Track,
-    Video,
-}
-
 /// A request [destination](https://fetch.spec.whatwg.org/#concept-request-destination)
 #[derive(Clone, Copy, Deserialize, MallocSizeOf, PartialEq, Serialize)]
 pub enum Destination {
     None,
+    Audio,
     Document,
     Embed,
     Font,
     Image,
     Manifest,
-    Media,
     Object,
     Report,
     Script,
     ServiceWorker,
     SharedWorker,
     Style,
+    Track,
+    Video,
     Worker,
-    XSLT,
+    Xslt,
+}
+
+impl Destination {
+    /// https://fetch.spec.whatwg.org/#request-destination-script-like
+    #[inline]
+    pub fn is_script_like(&self) -> bool {
+        *self == Destination::Script ||
+        *self == Destination::ServiceWorker ||
+        *self == Destination::SharedWorker ||
+        *self == Destination::Worker
+    }
 }
 
 /// A request [origin](https://fetch.spec.whatwg.org/#concept-request-origin)
@@ -150,7 +150,6 @@ pub struct RequestInit {
     pub body: Option<Vec<u8>>,
     pub service_workers_mode: ServiceWorkersMode,
     // TODO: client object
-    pub type_: Type,
     pub destination: Destination,
     pub synchronous: bool,
     pub mode: RequestMode,
@@ -178,7 +177,6 @@ impl Default for RequestInit {
             unsafe_request: false,
             body: None,
             service_workers_mode: ServiceWorkersMode::All,
-            type_: Type::None,
             destination: Destination::None,
             synchronous: false,
             mode: RequestMode::NoCors,
@@ -224,8 +222,6 @@ pub struct Request {
     pub service_workers_mode: ServiceWorkersMode,
     /// <https://fetch.spec.whatwg.org/#concept-request-initiator>
     pub initiator: Initiator,
-    /// <https://fetch.spec.whatwg.org/#concept-request-type>
-    pub type_: Type,
     /// <https://fetch.spec.whatwg.org/#concept-request-destination>
     pub destination: Destination,
     // TODO: priority object
@@ -278,7 +274,6 @@ impl Request {
             keep_alive: false,
             service_workers_mode: ServiceWorkersMode::All,
             initiator: Initiator::None,
-            type_: Type::None,
             destination: Destination::None,
             origin: origin.unwrap_or(Origin::Client),
             referrer: Referrer::Client,
@@ -307,7 +302,6 @@ impl Request {
         req.unsafe_request = init.unsafe_request;
         req.body = init.body;
         req.service_workers_mode = init.service_workers_mode;
-        req.type_ = init.type_;
         req.destination = init.destination;
         req.synchronous = init.synchronous;
         req.mode = init.mode;
@@ -356,8 +350,9 @@ impl Request {
     /// <https://fetch.spec.whatwg.org/#subresource-request>
     pub fn is_subresource_request(&self) -> bool {
         match self.destination {
-            Destination::Font | Destination::Image | Destination::Manifest | Destination::Media |
+            Destination::Audio | Destination::Font | Destination::Image | Destination::Manifest |
-            Destination::Script | Destination::Style | Destination::XSLT | Destination::None => true,
+            Destination::Script | Destination::Style | Destination::Track | Destination::Video |
+            Destination::Xslt | Destination::None => true,
             _ => false,
         }
     }

components/script/dom/dedicatedworkerglobalscope.rs

@@ -30,7 +30,7 @@ use js::jsapi::{JSAutoCompartment, JSContext, NullHandleValue};
 use js::jsval::UndefinedValue;
 use msg::constellation_msg::TopLevelBrowsingContextId;
 use net_traits::{IpcSend, load_whole_resource};
-use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
+use net_traits::request::{CredentialsMode, Destination, RequestInit};
 use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, new_rt_and_cx, Runtime};
 use script_runtime::ScriptThreadEventCategory::WorkerEvent;
 use script_traits::{TimerEvent, TimerSource, WorkerGlobalScopeInit, WorkerScriptLoadOrigin};
@@ -179,7 +179,6 @@ impl DedicatedWorkerGlobalScope {
 
             let request = RequestInit {
                 url: worker_url.clone(),
-                type_: RequestType::Script,
                 destination: Destination::Worker,
                 credentials_mode: CredentialsMode::Include,
                 use_url_credentials: true,

components/script/dom/htmlimageelement.rs

@@ -46,7 +46,7 @@ use net_traits::image::base::{Image, ImageMetadata};
 use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable};
 use net_traits::image_cache::{ImageResponder, ImageResponse, ImageState, PendingImageId};
 use net_traits::image_cache::UsePlaceholder;
-use net_traits::request::{RequestInit, Type as RequestType};
+use net_traits::request::RequestInit;
 use network_listener::{NetworkListener, PreInvoke};
 use num_traits::ToPrimitive;
 use script_thread::ScriptThread;
@@ -275,7 +275,6 @@ impl HTMLImageElement {
         let request = RequestInit {
             url: img_url.clone(),
             origin: document.origin().immutable().clone(),
-            type_: RequestType::Image,
             pipeline_id: Some(document.global().pipeline_id()),
             .. RequestInit::default()
         };

components/script/dom/htmlmediaelement.rs

@@ -37,7 +37,7 @@ use ipc_channel::router::ROUTER;
 use microtask::{Microtask, MicrotaskRunnable};
 use mime::{Mime, SubLevel, TopLevel};
 use net_traits::{FetchResponseListener, FetchMetadata, Metadata, NetworkError};
-use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
+use net_traits::request::{CredentialsMode, Destination, RequestInit};
 use network_listener::{NetworkListener, PreInvoke};
 use script_thread::ScriptThread;
 use servo_url::ServoUrl;
@@ -586,14 +586,13 @@ impl HTMLMediaElement {
                 // Step 4.remote.2.
                 // FIXME(nox): Handle CORS setting from crossorigin attribute.
                 let document = document_from_node(self);
-                let type_ = match self.media_type_id() {
+                let destination = match self.media_type_id() {
-                    HTMLMediaElementTypeId::HTMLAudioElement => RequestType::Audio,
+                    HTMLMediaElementTypeId::HTMLAudioElement => Destination::Audio,
-                    HTMLMediaElementTypeId::HTMLVideoElement => RequestType::Video,
+                    HTMLMediaElementTypeId::HTMLVideoElement => Destination::Video,
                 };
                 let request = RequestInit {
                     url,
-                    type_,
+                    destination,
-                    destination: Destination::Media,
                     credentials_mode: CredentialsMode::Include,
                     use_url_credentials: true,
                     origin: document.origin().immutable().clone(),

components/script/dom/htmlscriptelement.rs

@@ -30,7 +30,7 @@ use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use js::jsval::UndefinedValue;
 use net_traits::{FetchMetadata, FetchResponseListener, Metadata, NetworkError};
-use net_traits::request::{CorsSettings, CredentialsMode, Destination, RequestInit, RequestMode, Type as RequestType};
+use net_traits::request::{CorsSettings, CredentialsMode, Destination, RequestInit, RequestMode};
 use network_listener::{NetworkListener, PreInvoke};
 use servo_atoms::Atom;
 use servo_config::opts;
@@ -238,7 +238,6 @@ fn fetch_a_classic_script(script: &HTMLScriptElement,
     // Step 1, 2.
     let request = RequestInit {
         url: url.clone(),
-        type_: RequestType::Script,
         destination: Destination::Script,
         // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
         // Step 1

components/script/dom/request.rs

@@ -15,7 +15,6 @@ use dom::bindings::codegen::Bindings::RequestBinding::RequestInit;
 use dom::bindings::codegen::Bindings::RequestBinding::RequestMethods;
 use dom::bindings::codegen::Bindings::RequestBinding::RequestMode;
 use dom::bindings::codegen::Bindings::RequestBinding::RequestRedirect;
-use dom::bindings::codegen::Bindings::RequestBinding::RequestType;
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
 use dom::bindings::root::{DomRoot, MutNullableDom};
@@ -36,7 +35,6 @@ use net_traits::request::RedirectMode as NetTraitsRequestRedirect;
 use net_traits::request::Referrer as NetTraitsRequestReferrer;
 use net_traits::request::Request as NetTraitsRequest;
 use net_traits::request::RequestMode as NetTraitsRequestMode;
-use net_traits::request::Type as NetTraitsRequestType;
 use servo_url::ServoUrl;
 use std::cell::{Cell, Ref};
 use std::rc::Rc;
@@ -526,11 +524,6 @@ impl RequestMethods for Request {
         self.headers.or_init(|| Headers::new(&self.global()))
     }
 
-    // https://fetch.spec.whatwg.org/#dom-request-type
-    fn Type(&self) -> RequestType {
-        self.request.borrow().type_.into()
-    }
-
     // https://fetch.spec.whatwg.org/#dom-request-destination
     fn Destination(&self) -> RequestDestination {
         self.request.borrow().destination.into()
@@ -703,20 +696,21 @@ impl Into<NetTraitsRequestDestination> for RequestDestination {
     fn into(self) -> NetTraitsRequestDestination {
         match self {
             RequestDestination::_empty => NetTraitsRequestDestination::None,
+            RequestDestination::Audio => NetTraitsRequestDestination::Audio,
             RequestDestination::Document => NetTraitsRequestDestination::Document,
             RequestDestination::Embed => NetTraitsRequestDestination::Embed,
             RequestDestination::Font => NetTraitsRequestDestination::Font,
             RequestDestination::Image => NetTraitsRequestDestination::Image,
             RequestDestination::Manifest => NetTraitsRequestDestination::Manifest,
-            RequestDestination::Media => NetTraitsRequestDestination::Media,
             RequestDestination::Object => NetTraitsRequestDestination::Object,
             RequestDestination::Report => NetTraitsRequestDestination::Report,
             RequestDestination::Script => NetTraitsRequestDestination::Script,
-            RequestDestination::Serviceworker => NetTraitsRequestDestination::ServiceWorker,
             RequestDestination::Sharedworker => NetTraitsRequestDestination::SharedWorker,
             RequestDestination::Style => NetTraitsRequestDestination::Style,
+            RequestDestination::Track => NetTraitsRequestDestination::Track,
+            RequestDestination::Video => NetTraitsRequestDestination::Video,
             RequestDestination::Worker => NetTraitsRequestDestination::Worker,
-            RequestDestination::Xslt => NetTraitsRequestDestination::XSLT,
+            RequestDestination::Xslt => NetTraitsRequestDestination::Xslt,
         }
     }
 }
@@ -725,50 +719,23 @@ impl Into<RequestDestination> for NetTraitsRequestDestination {
     fn into(self) -> RequestDestination {
         match self {
             NetTraitsRequestDestination::None => RequestDestination::_empty,
+            NetTraitsRequestDestination::Audio => RequestDestination::Audio,
             NetTraitsRequestDestination::Document => RequestDestination::Document,
             NetTraitsRequestDestination::Embed => RequestDestination::Embed,
             NetTraitsRequestDestination::Font => RequestDestination::Font,
             NetTraitsRequestDestination::Image => RequestDestination::Image,
             NetTraitsRequestDestination::Manifest => RequestDestination::Manifest,
-            NetTraitsRequestDestination::Media => RequestDestination::Media,
             NetTraitsRequestDestination::Object => RequestDestination::Object,
             NetTraitsRequestDestination::Report => RequestDestination::Report,
             NetTraitsRequestDestination::Script => RequestDestination::Script,
-            NetTraitsRequestDestination::ServiceWorker => RequestDestination::Serviceworker,
+            NetTraitsRequestDestination::ServiceWorker
+                => panic!("ServiceWorker request destination should not be exposed to DOM"),
             NetTraitsRequestDestination::SharedWorker => RequestDestination::Sharedworker,
             NetTraitsRequestDestination::Style => RequestDestination::Style,
-            NetTraitsRequestDestination::XSLT => RequestDestination::Xslt,
+            NetTraitsRequestDestination::Track => RequestDestination::Track,
+            NetTraitsRequestDestination::Video => RequestDestination::Video,
             NetTraitsRequestDestination::Worker => RequestDestination::Worker,
-        }
+            NetTraitsRequestDestination::Xslt => RequestDestination::Xslt,
-    }
-}
-
-impl Into<NetTraitsRequestType> for RequestType {
-    fn into(self) -> NetTraitsRequestType {
-        match self {
-            RequestType::_empty => NetTraitsRequestType::None,
-            RequestType::Audio => NetTraitsRequestType::Audio,
-            RequestType::Font => NetTraitsRequestType::Font,
-            RequestType::Image => NetTraitsRequestType::Image,
-            RequestType::Script => NetTraitsRequestType::Script,
-            RequestType::Style => NetTraitsRequestType::Style,
-            RequestType::Track => NetTraitsRequestType::Track,
-            RequestType::Video => NetTraitsRequestType::Video,
-        }
-    }
-}
-
-impl Into<RequestType> for NetTraitsRequestType {
-    fn into(self) -> RequestType {
-        match self {
-            NetTraitsRequestType::None => RequestType::_empty,
-            NetTraitsRequestType::Audio => RequestType::Audio,
-            NetTraitsRequestType::Font => RequestType::Font,
-            NetTraitsRequestType::Image => RequestType::Image,
-            NetTraitsRequestType::Script => RequestType::Script,
-            NetTraitsRequestType::Style => RequestType::Style,
-            NetTraitsRequestType::Track => RequestType::Track,
-            NetTraitsRequestType::Video => RequestType::Video,
         }
     }
 }

components/script/dom/serviceworkerglobalscope.rs

@@ -23,7 +23,7 @@ use ipc_channel::router::ROUTER;
 use js::jsapi::{JS_SetInterruptCallback, JSAutoCompartment, JSContext};
 use js::jsval::UndefinedValue;
 use net_traits::{load_whole_resource, IpcSend, CustomResponseMediator};
-use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
+use net_traits::request::{CredentialsMode, Destination, RequestInit};
 use script_runtime::{CommonScriptMsg, ScriptChan, new_rt_and_cx, Runtime};
 use script_traits::{TimerEvent, WorkerGlobalScopeInit, ScopeThings, ServiceWorkerMsg, WorkerScriptLoadOrigin};
 use servo_config::prefs::PREFS;
@@ -161,7 +161,6 @@ impl ServiceWorkerGlobalScope {
 
             let request = RequestInit {
                 url: script_url.clone(),
-                type_: RequestType::Script,
                 destination: Destination::ServiceWorker,
                 credentials_mode: CredentialsMode::Include,
                 use_url_credentials: true,

components/script/dom/webidls/Request.webidl

@@ -13,7 +13,7 @@ interface Request {
   readonly attribute ByteString method;
   readonly attribute USVString url;
   [SameObject] readonly attribute Headers headers;
-  readonly attribute RequestType type;
+
   readonly attribute RequestDestination destination;
   readonly attribute USVString referrer;
   readonly attribute ReferrerPolicy referrerPolicy;
@@ -22,6 +22,7 @@ interface Request {
   readonly attribute RequestCache cache;
   readonly attribute RequestRedirect redirect;
   readonly attribute DOMString integrity;
+
   [NewObject, Throws] Request clone();
 };
 
@@ -41,31 +42,21 @@ dictionary RequestInit {
   any window; // can only be set to null
 };
 
-enum RequestType {
-  "",
-  "audio",
-  "font",
-  "image",
-  "script",
-  "style",
-  "track",
-  "video"
-};
-
 enum RequestDestination {
   "",
+  "audio",
   "document",
   "embed",
   "font",
   "image",
   "manifest",
-  "media",
   "object",
   "report",
   "script",
-  "serviceworker",
   "sharedworker",
   "style",
+  "track",
+  "video",
   "worker",
   "xslt"
 };

components/script/dom/workerglobalscope.rs

@@ -30,7 +30,7 @@ use js::jsapi::{HandleValue, JSAutoCompartment, JSContext, JSRuntime};
 use js::jsval::UndefinedValue;
 use js::panic::maybe_resume_unwind;
 use net_traits::{IpcSend, load_whole_resource};
-use net_traits::request::{CredentialsMode, Destination, RequestInit as NetRequestInit, Type as RequestType};
+use net_traits::request::{CredentialsMode, Destination, RequestInit as NetRequestInit};
 use script_runtime::{CommonScriptMsg, ScriptChan, ScriptPort, get_reports, Runtime};
 use script_traits::{TimerEvent, TimerEventId};
 use script_traits::WorkerGlobalScopeInit;
@@ -199,7 +199,6 @@ impl WorkerGlobalScopeMethods for WorkerGlobalScope {
             let global_scope = self.upcast::<GlobalScope>();
             let request = NetRequestInit {
                 url: url.clone(),
-                type_: RequestType::Script,
                 destination: Destination::Script,
                 credentials_mode: CredentialsMode::Include,
                 use_url_credentials: true,

components/script/dom/worklet.rs

@@ -43,7 +43,6 @@ use net_traits::load_whole_resource;
 use net_traits::request::Destination;
 use net_traits::request::RequestInit;
 use net_traits::request::RequestMode;
-use net_traits::request::Type as RequestType;
 use script_runtime::CommonScriptMsg;
 use script_runtime::Runtime;
 use script_runtime::ScriptThreadEventCategory;
@@ -573,7 +572,6 @@ impl WorkletThread {
         let resource_fetcher = self.global_init.resource_threads.sender();
         let request = RequestInit {
             url: script_url,
-            type_: RequestType::Script,
             destination: Destination::Script,
             mode: RequestMode::CorsMode,
             credentials_mode: credentials.into(),

components/script/fetch.rs

@@ -49,7 +49,6 @@ fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit
         headers: request.headers.clone(),
         unsafe_request: request.unsafe_request,
         body: request.body.clone(),
-        type_: request.type_,
         destination: request.destination,
         synchronous: request.synchronous,
         mode: request.mode,

components/script/layout_image.rs

@@ -13,7 +13,7 @@ use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use net_traits::{FetchResponseMsg, FetchResponseListener, FetchMetadata, NetworkError};
 use net_traits::image_cache::{ImageCache, PendingImageId};
-use net_traits::request::{Type as RequestType, RequestInit as FetchRequestInit};
+use net_traits::request::{Destination, RequestInit as FetchRequestInit};
 use network_listener::{NetworkListener, PreInvoke};
 use servo_url::ServoUrl;
 use std::sync::{Arc, Mutex};
@@ -71,7 +71,7 @@ pub fn fetch_image_for_layout(url: ServoUrl,
     let request = FetchRequestInit {
         url: url,
         origin: document.origin().immutable().clone(),
-        type_: RequestType::Image,
+        destination: Destination::Image,
         pipeline_id: Some(document.global().pipeline_id()),
         .. FetchRequestInit::default()
     };

components/script/stylesheet_loader.rs

@@ -21,7 +21,7 @@ use hyper_serde::Serde;
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use net_traits::{FetchResponseListener, FetchMetadata, FilteredMetadata, Metadata, NetworkError, ReferrerPolicy};
-use net_traits::request::{CorsSettings, CredentialsMode, Destination, RequestInit, RequestMode, Type as RequestType};
+use net_traits::request::{CorsSettings, CredentialsMode, Destination, RequestInit, RequestMode};
 use network_listener::{NetworkListener, PreInvoke};
 use parking_lot::RwLock;
 use servo_arc::Arc;
@@ -247,7 +247,6 @@ impl<'a> StylesheetLoader<'a> {
 
         let request = RequestInit {
             url: url.clone(),
-            type_: RequestType::Style,
             destination: Destination::Style,
             // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
             // Step 1

tests/unit/net/fetch.rs

@@ -32,7 +32,7 @@ use net::test::HttpState;
 use net_traits::IncludeSubdomains;
 use net_traits::NetworkError;
 use net_traits::ReferrerPolicy;
-use net_traits::request::{Origin, RedirectMode, Referrer, Request, RequestMode, Type};
+use net_traits::request::{Destination, Origin, RedirectMode, Referrer, Request, RequestMode};
 use net_traits::response::{CacheState, Response, ResponseBody, ResponseType};
 use servo_config::resource_files::resources_dir_path;
 use servo_url::{ImmutableOrigin, ServoUrl};
@@ -610,7 +610,7 @@ fn test_fetch_with_sri_sucess() {
 #[test]
 fn test_fetch_blocked_nosniff() {
     #[inline]
-    fn test_nosniff_request(request_type: Type,
+    fn test_nosniff_request(destination: Destination,
                             mime: Mime,
                             should_error: bool) {
         const MESSAGE: &'static [u8] = b"";
@@ -631,7 +631,7 @@ fn test_fetch_blocked_nosniff() {
 
         let origin = Origin::Origin(url.origin());
         let mut request = Request::new(url, Some(origin), None);
-        request.type_ = request_type;
+        request.destination = destination;
         let fetch_response = fetch(&mut request, None);
         let _ = server.close();
 
@@ -639,14 +639,14 @@ fn test_fetch_blocked_nosniff() {
     }
 
     let tests = vec![
-        (Type::Script, Mime(TopLevel::Text, SubLevel::Javascript, vec![]), false),
+        (Destination::Script, Mime(TopLevel::Text, SubLevel::Javascript, vec![]), false),
-        (Type::Script, Mime(TopLevel::Text, SubLevel::Css, vec![]), true),
+        (Destination::Script, Mime(TopLevel::Text, SubLevel::Css, vec![]), true),
-        (Type::Style,  Mime(TopLevel::Text, SubLevel::Css, vec![]), false),
+        (Destination::Style,  Mime(TopLevel::Text, SubLevel::Css, vec![]), false),
     ];
 
     for test in tests {
-        let (type_, mime, should_error) = test;
+        let (destination, mime, should_error) = test;
-        test_nosniff_request(type_, mime, should_error);
+        test_nosniff_request(destination, mime, should_error);
     }
 }
 

tests/wpt/metadata/fetch/api/request/request-type-attribute-historical.html.ini

@@ -1,5 +0,0 @@
-[request-type-attribute-historical.html]
-  type: testharness
-  ['type' getter should not exist on Request objects]
-    expected: FAIL
-