Remove TimingOrigin

Author: yoshuawuyts

src/security/mod.rs

@@ -22,7 +22,7 @@ mod timing_allow_origin;
 
 pub use csp::{ContentSecurityPolicy, ReportTo, ReportToEndpoint, Source};
 #[doc(inline)]
-pub use timing_allow_origin::{TimingAllowOrigin, TimingOrigin};
+pub use timing_allow_origin::{TimingAllowOrigin};
 
 /// Apply a set of default protections.
 ///

src/security/timing_allow_origin.rs

@@ -10,18 +10,18 @@
 //! ```
 //! # fn main() -> http_types::Result<()> {
 //! #
-//! use http_types::Response;
-//! use http_types::security::{TimingAllowOrigin, TimingOrigin};
+//! use http_types::{Response, Url};
+//! use http_types::security::TimingAllowOrigin;
 //!
 //! let mut origins = TimingAllowOrigin::new();
-//! origins.push(TimingOrigin::Wildcard);
+//! origins.push(Url::parse("https://example.com")?);
 //!
 //! let mut res = Response::new(200);
 //! origins.apply(&mut res);
 //!
 //! let origins = TimingAllowOrigin::from_headers(res)?.unwrap();
 //! let origin = origins.iter().next().unwrap();
-//! assert_eq!(origin, &TimingOrigin::Wildcard);
+//! assert_eq!(origin, &Url::parse("https://example.com")?);
 //! #
 //! # Ok(()) }
 //! ```
@@ -42,30 +42,31 @@ use std::slice;
 /// ```
 /// # fn main() -> http_types::Result<()> {
 /// #
-/// use http_types::Response;
-/// use http_types::security::{TimingAllowOrigin, TimingOrigin};
+/// use http_types::{Response, Url};
+/// use http_types::security::TimingAllowOrigin;
 ///
 /// let mut origins = TimingAllowOrigin::new();
-/// origins.push(TimingOrigin::Wildcard);
+/// origins.push(Url::parse("https://example.com")?);
 ///
 /// let mut res = Response::new(200);
 /// origins.apply(&mut res);
 ///
 /// let origins = TimingAllowOrigin::from_headers(res)?.unwrap();
 /// let origin = origins.iter().next().unwrap();
-/// assert_eq!(origin, &TimingOrigin::Wildcard);
+/// assert_eq!(origin, &Url::parse("https://example.com")?);
 /// #
 /// # Ok(()) }
 /// ```
 #[derive(Clone, Eq, PartialEq)]
 pub struct TimingAllowOrigin {
-    origins: Vec<TimingOrigin>,
+    origins: Vec<Url>,
+    wildcard: bool,
 }
 
 impl TimingAllowOrigin {
     /// Create a new instance of `AllowOrigin`.
     pub fn new() -> Self {
-        Self { origins: vec![] }
+        Self { origins: vec![], wildcard: false, }
     }
 
     /// Create an instance of `AllowOrigin` from a `Headers` instance.
@@ -79,25 +80,26 @@ impl TimingAllowOrigin {
             None => return Ok(None),
         };
 
+        let mut wildcard = false;
         let mut origins = vec![];
         for header in headers {
             for origin in header.as_str().split(',') {
                 match origin.trim_start() {
-                    "*" => origins.push(TimingOrigin::Wildcard),
+                    "*" => wildcard = true,
                     r#""null""# => continue,
                     origin => {
                         let url = Url::parse(origin).status(400)?;
-                        origins.push(TimingOrigin::Url(url));
+                        origins.push(url);
                     }
                 }
             }
         }
 
-        Ok(Some(Self { origins }))
+        Ok(Some(Self { origins, wildcard }))
     }
 
     /// Append an origin to the list of origins.
-    pub fn push(&mut self, origin: impl Into<TimingOrigin>) {
+    pub fn push(&mut self, origin: impl Into<Url>) {
         self.origins.push(origin.into());
     }
 
@@ -115,17 +117,33 @@ impl TimingAllowOrigin {
     pub fn value(&self) -> HeaderValue {
         let mut output = String::new();
         for (n, origin) in self.origins.iter().enumerate() {
-            let origin: HeaderValue = origin.clone().into();
             match n {
                 0 => write!(output, "{}", origin).unwrap(),
                 _ => write!(output, ", {}", origin).unwrap(),
             };
         }
 
+        if self.wildcard {
+            match output.len() {
+                0 => write!(output, "*").unwrap(),
+                _ => write!(output, ", *").unwrap(),
+            };
+        }
+
         // SAFETY: the internal string is validated to be ASCII.
         unsafe { HeaderValue::from_bytes_unchecked(output.into()) }
     }
 
+    /// Returns `true` if a wildcard directive was set.
+    pub fn wildcard(&self) -> bool {
+        self.wildcard
+    }
+
+    /// Set the wildcard directive.
+    pub fn set_wildcard(&mut self, wildcard: bool) {
+        self.wildcard = wildcard
+    }
+
     /// An iterator visiting all server timings.
     pub fn iter(&self) -> Iter<'_> {
         Iter {
@@ -142,7 +160,7 @@ impl TimingAllowOrigin {
 }
 
 impl IntoIterator for TimingAllowOrigin {
-    type Item = TimingOrigin;
+    type Item = Url;
     type IntoIter = IntoIter;
 
     #[inline]
@@ -154,7 +172,7 @@ impl IntoIterator for TimingAllowOrigin {
 }
 
 impl<'a> IntoIterator for &'a TimingAllowOrigin {
-    type Item = &'a TimingOrigin;
+    type Item = &'a Url;
     type IntoIter = Iter<'a>;
 
     // #[inline]serv
@@ -164,7 +182,7 @@ impl<'a> IntoIterator for &'a TimingAllowOrigin {
 }
 
 impl<'a> IntoIterator for &'a mut TimingAllowOrigin {
-    type Item = &'a mut TimingOrigin;
+    type Item = &'a mut Url;
     type IntoIter = IterMut<'a>;
 
     #[inline]
@@ -176,11 +194,11 @@ impl<'a> IntoIterator for &'a mut TimingAllowOrigin {
 /// A borrowing iterator over entries in `AllowOrigin`.
 #[derive(Debug)]
 pub struct IntoIter {
-    inner: std::vec::IntoIter<TimingOrigin>,
+    inner: std::vec::IntoIter<Url>,
 }
 
 impl Iterator for IntoIter {
-    type Item = TimingOrigin;
+    type Item = Url;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
@@ -195,11 +213,11 @@ impl Iterator for IntoIter {
 /// A lending iterator over entries in `AllowOrigin`.
 #[derive(Debug)]
 pub struct Iter<'a> {
-    inner: slice::Iter<'a, TimingOrigin>,
+    inner: slice::Iter<'a, Url>,
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = &'a TimingOrigin;
+    type Item = &'a Url;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
@@ -214,11 +232,11 @@ impl<'a> Iterator for Iter<'a> {
 /// A mutable iterator over entries in `AllowOrigin`.
 #[derive(Debug)]
 pub struct IterMut<'a> {
-    inner: slice::IterMut<'a, TimingOrigin>,
+    inner: slice::IterMut<'a, Url>,
 }
 
 impl<'a> Iterator for IterMut<'a> {
-    type Item = &'a mut TimingOrigin;
+    type Item = &'a mut Url;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
@@ -248,41 +266,6 @@ impl Debug for TimingAllowOrigin {
     }
 }
 
-/// An origin passed into `AllowOrigin`.
-///
-/// Values can either be `Url` or `Wildcard`. `"null"` values are skipped during parsing.
-//
-// NOTE: this origin is different than the origin in the fetch spec. It needs to
-// be its own type.
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum TimingOrigin {
-    /// An origin URL.
-    Url(Url),
-    /// Allow all origins.
-    Wildcard,
-}
-
-impl From<Url> for TimingOrigin {
-    fn from(url: Url) -> Self {
-        TimingOrigin::Url(url)
-    }
-}
-
-impl From<TimingOrigin> for HeaderValue {
-    fn from(entry: TimingOrigin) -> HeaderValue {
-        unsafe {
-            match entry {
-                TimingOrigin::Url(url) => {
-                    HeaderValue::from_bytes_unchecked(format!("{}", url).into_bytes())
-                }
-                TimingOrigin::Wildcard => {
-                    HeaderValue::from_bytes_unchecked(String::from("*").into_bytes())
-                }
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -291,34 +274,33 @@ mod test {
     #[test]
     fn smoke() -> crate::Result<()> {
         let mut origins = TimingAllowOrigin::new();
-        origins.push(TimingOrigin::Wildcard);
+        origins.push(Url::parse("https://example.com")?);
 
         let mut headers = Headers::new();
         origins.apply(&mut headers);
 
         let origins = TimingAllowOrigin::from_headers(headers)?.unwrap();
         let origin = origins.iter().next().unwrap();
-        assert_eq!(origin, &TimingOrigin::Wildcard);
+        assert_eq!(origin, &Url::parse("https://example.com")?);
         Ok(())
     }
 
     #[test]
     fn multi() -> crate::Result<()> {
         let mut origins = TimingAllowOrigin::new();
-        origins.push(TimingOrigin::Wildcard);
-        origins.push(TimingOrigin::Url(Url::parse("https://mozilla.org/")?));
+        origins.push(Url::parse("https://example.com")?);
+        origins.push(Url::parse("https://mozilla.org/")?);
 
         let mut headers = Headers::new();
         origins.apply(&mut headers);
 
         let origins = TimingAllowOrigin::from_headers(headers)?.unwrap();
         let mut origins = origins.iter();
         let origin = origins.next().unwrap();
-        assert!(matches!(origin, TimingOrigin::Wildcard));
+        assert_eq!(origin, &Url::parse("https://example.com")?);
 
         let origin = origins.next().unwrap();
-        let rhs = Url::parse("https://mozilla.org/")?;
-        assert_eq!(origin, &TimingOrigin::Url(rhs));
+        assert_eq!(origin, &Url::parse("https://mozilla.org/")?);
         Ok(())
     }
 
@@ -330,4 +312,22 @@ mod test {
         assert_eq!(err.status(), 400);
         Ok(())
     }
+
+    #[test]
+    fn wildcard() -> crate::Result<()> {
+        let mut origins = TimingAllowOrigin::new();
+        origins.push(Url::parse("https://example.com")?);
+        origins.set_wildcard(true);
+
+        let mut headers = Headers::new();
+        origins.apply(&mut headers);
+
+        let origins = TimingAllowOrigin::from_headers(headers)?.unwrap();
+        assert_eq!(origins.wildcard(), true);
+        let origin = origins.iter().next().unwrap();
+        assert_eq!(origin, &Url::parse("https://example.com")?);
+        Ok(())
+    }
+
+
 }