Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

12 files changed, 4135 insertions, 0 deletions

diff --git a/third_party/rust/cookie/src/builder.rs b/third_party/rust/cookie/src/builder.rs
new file mode 100644
index 0000000000..78d1219a9a
--- /dev/null
+++ b/third_party/rust/cookie/src/builder.rs
@@ -0,0 +1,246 @@
+use std::borrow::Cow;
+
+use crate::{Cookie, SameSite, Expiration};
+
+/// Structure that follows the builder pattern for building `Cookie` structs.
+///
+/// To construct a cookie:
+///
+///   1. Call [`Cookie::build`] to start building.
+///   2. Use any of the builder methods to set fields in the cookie.
+///   3. Call [`CookieBuilder::finish()`] to retrieve the built cookie.
+///
+/// # Example
+///
+/// ```rust
+/// # extern crate cookie;
+/// use cookie::Cookie;
+/// use cookie::time::Duration;
+///
+/// # fn main() {
+/// let cookie: Cookie = Cookie::build("name", "value")
+///     .domain("www.rust-lang.org")
+///     .path("/")
+///     .secure(true)
+///     .http_only(true)
+///     .max_age(Duration::days(1))
+///     .finish();
+/// # }
+/// ```
+#[derive(Debug, Clone)]
+pub struct CookieBuilder<'c> {
+    /// The cookie being built.
+    cookie: Cookie<'c>,
+}
+
+impl<'c> CookieBuilder<'c> {
+    /// Creates a new `CookieBuilder` instance from the given name and value.
+    ///
+    /// This method is typically called indirectly via [`Cookie::build()`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar").finish();
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// ```
+    pub fn new<N, V>(name: N, value: V) -> Self
+        where N: Into<Cow<'c, str>>,
+              V: Into<Cow<'c, str>>
+    {
+        CookieBuilder { cookie: Cookie::new(name, value) }
+    }
+
+    /// Sets the `expires` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::{Cookie, Expiration};
+    /// use cookie::time::OffsetDateTime;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .expires(OffsetDateTime::now_utc())
+    ///     .finish();
+    ///
+    /// assert!(c.expires().is_some());
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .expires(None)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.expires(), Some(Expiration::Session));
+    /// # }
+    /// ```
+    #[inline]
+    pub fn expires<E: Into<Expiration>>(mut self, when: E) -> Self {
+        self.cookie.set_expires(when);
+        self
+    }
+
+    /// Sets the `max_age` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::Cookie;
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .max_age(Duration::minutes(30))
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(Duration::seconds(30 * 60)));
+    /// # }
+    /// ```
+    #[inline]
+    pub fn max_age(mut self, value: time::Duration) -> Self {
+        self.cookie.set_max_age(value);
+        self
+    }
+
+    /// Sets the `domain` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .domain("www.rust-lang.org")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.domain(), Some("www.rust-lang.org"));
+    /// ```
+    pub fn domain<D: Into<Cow<'c, str>>>(mut self, value: D) -> Self {
+        self.cookie.set_domain(value);
+        self
+    }
+
+    /// Sets the `path` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    pub fn path<P: Into<Cow<'c, str>>>(mut self, path: P) -> Self {
+        self.cookie.set_path(path);
+        self
+    }
+
+    /// Sets the `secure` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .secure(true)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.secure(), Some(true));
+    /// ```
+    #[inline]
+    pub fn secure(mut self, value: bool) -> Self {
+        self.cookie.set_secure(value);
+        self
+    }
+
+    /// Sets the `http_only` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .http_only(true)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.http_only(), Some(true));
+    /// ```
+    #[inline]
+    pub fn http_only(mut self, value: bool) -> Self {
+        self.cookie.set_http_only(value);
+        self
+    }
+
+    /// Sets the `same_site` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{Cookie, SameSite};
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .same_site(SameSite::Strict)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.same_site(), Some(SameSite::Strict));
+    /// ```
+    #[inline]
+    pub fn same_site(mut self, value: SameSite) -> Self {
+        self.cookie.set_same_site(value);
+        self
+    }
+
+    /// Makes the cookie being built 'permanent' by extending its expiration and
+    /// max age 20 years into the future.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::Cookie;
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .permanent()
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
+    /// # assert!(c.expires().is_some());
+    /// # }
+    /// ```
+    #[inline]
+    pub fn permanent(mut self) -> Self {
+        self.cookie.make_permanent();
+        self
+    }
+
+    /// Finishes building and returns the built `Cookie`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .domain("crates.io")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// assert_eq!(c.domain(), Some("crates.io"));
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    #[inline]
+    pub fn finish(self) -> Cookie<'c> {
+        self.cookie
+    }
+}
diff --git a/third_party/rust/cookie/src/delta.rs b/third_party/rust/cookie/src/delta.rs
new file mode 100644
index 0000000000..3ef35fadd7
--- /dev/null
+++ b/third_party/rust/cookie/src/delta.rs
@@ -0,0 +1,65 @@
+use std::ops::{Deref, DerefMut};
+use std::hash::{Hash, Hasher};
+use std::borrow::Borrow;
+
+use crate::Cookie;
+
+/// A `DeltaCookie` is a helper structure used in a cookie jar. It wraps a
+/// `Cookie` so that it can be hashed and compared purely by name. It further
+/// records whether the wrapped cookie is a "removal" cookie, that is, a cookie
+/// that when sent to the client removes the named cookie on the client's
+/// machine.
+#[derive(Clone, Debug)]
+pub struct DeltaCookie {
+    pub cookie: Cookie<'static>,
+    pub removed: bool,
+}
+
+impl DeltaCookie {
+    /// Create a new `DeltaCookie` that is being added to a jar.
+    #[inline]
+    pub fn added(cookie: Cookie<'static>) -> DeltaCookie {
+        DeltaCookie { cookie, removed: false, }
+    }
+
+    /// Create a new `DeltaCookie` that is being removed from a jar. The
+    /// `cookie` should be a "removal" cookie.
+    #[inline]
+    pub fn removed(cookie: Cookie<'static>) -> DeltaCookie {
+        DeltaCookie { cookie, removed: true, }
+    }
+}
+
+impl Deref for DeltaCookie {
+    type Target = Cookie<'static>;
+
+    fn deref(&self) -> &Cookie<'static> {
+        &self.cookie
+    }
+}
+
+impl DerefMut for DeltaCookie {
+    fn deref_mut(&mut self) -> &mut Cookie<'static> {
+        &mut self.cookie
+    }
+}
+
+impl PartialEq for DeltaCookie {
+    fn eq(&self, other: &DeltaCookie) -> bool {
+        self.name() == other.name()
+    }
+}
+
+impl Eq for DeltaCookie {}
+
+impl Hash for DeltaCookie {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name().hash(state);
+    }
+}
+
+impl Borrow<str> for DeltaCookie {
+    fn borrow(&self) -> &str {
+        self.name()
+    }
+}
diff --git a/third_party/rust/cookie/src/draft.rs b/third_party/rust/cookie/src/draft.rs
new file mode 100644
index 0000000000..e625e81c90
--- /dev/null
+++ b/third_party/rust/cookie/src/draft.rs
@@ -0,0 +1,108 @@
+//! This module contains types that represent cookie properties that are not yet
+//! standardized. That is, _draft_ features.
+
+use std::fmt;
+
+/// The `SameSite` cookie attribute.
+///
+/// A cookie with a `SameSite` attribute is imposed restrictions on when it is
+/// sent to the origin server in a cross-site request. If the `SameSite`
+/// attribute is "Strict", then the cookie is never sent in cross-site requests.
+/// If the `SameSite` attribute is "Lax", the cookie is only sent in cross-site
+/// requests with "safe" HTTP methods, i.e, `GET`, `HEAD`, `OPTIONS`, `TRACE`.
+/// If the `SameSite` attribute is "None", the cookie is sent in all cross-site
+/// requests if the "Secure" flag is also set, otherwise the cookie is ignored.
+/// This library automatically sets the "Secure" flag on cookies when
+/// `same_site` is set to `SameSite::None` as long as `secure` is not explicitly
+/// set to `false`.
+///
+/// If the `SameSite` attribute is not present (by not setting `SameSite`
+/// initally or passing `None` to [`Cookie::set_same_site()`]), then the cookie
+/// will be sent as normal.
+///
+/// **Note:** This cookie attribute is an [HTTP draft]! Its meaning and
+/// definition are subject to change.
+///
+/// [`Cookie::set_same_site()`]: crate::Cookie::set_same_site()
+/// [HTTP draft]: https://tools.ietf.org/html/draft-west-cookie-incrementalism-00
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SameSite {
+    /// The "Strict" `SameSite` attribute.
+    Strict,
+    /// The "Lax" `SameSite` attribute.
+    Lax,
+    /// The "None" `SameSite` attribute.
+    None
+}
+
+impl SameSite {
+    /// Returns `true` if `self` is `SameSite::Strict` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::SameSite;
+    ///
+    /// let strict = SameSite::Strict;
+    /// assert!(strict.is_strict());
+    /// assert!(!strict.is_lax());
+    /// assert!(!strict.is_none());
+    /// ```
+    #[inline]
+    pub fn is_strict(&self) -> bool {
+        match *self {
+            SameSite::Strict => true,
+            SameSite::Lax | SameSite::None => false,
+        }
+    }
+
+    /// Returns `true` if `self` is `SameSite::Lax` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::SameSite;
+    ///
+    /// let lax = SameSite::Lax;
+    /// assert!(lax.is_lax());
+    /// assert!(!lax.is_strict());
+    /// assert!(!lax.is_none());
+    /// ```
+    #[inline]
+    pub fn is_lax(&self) -> bool {
+        match *self {
+            SameSite::Lax => true,
+            SameSite::Strict | SameSite::None => false,
+        }
+    }
+
+    /// Returns `true` if `self` is `SameSite::None` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::SameSite;
+    ///
+    /// let none = SameSite::None;
+    /// assert!(none.is_none());
+    /// assert!(!none.is_lax());
+    /// assert!(!none.is_strict());
+    /// ```
+    #[inline]
+    pub fn is_none(&self) -> bool {
+        match *self {
+            SameSite::None => true,
+            SameSite::Lax | SameSite::Strict => false
+        }
+    }
+}
+
+impl fmt::Display for SameSite {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            SameSite::Strict => write!(f, "Strict"),
+            SameSite::Lax => write!(f, "Lax"),
+            SameSite::None => write!(f, "None"),
+        }
+    }
+}
diff --git a/third_party/rust/cookie/src/expiration.rs b/third_party/rust/cookie/src/expiration.rs
new file mode 100644
index 0000000000..2ff2885483
--- /dev/null
+++ b/third_party/rust/cookie/src/expiration.rs
@@ -0,0 +1,137 @@
+use time::OffsetDateTime;
+
+/// A cookie's expiration: either session or a date-time.
+///
+/// An `Expiration` is constructible via `Expiration::from()` with an
+/// `Option<OffsetDateTime>` or an `OffsetDateTime`:
+///
+///   * `None` -> `Expiration::Session`
+///   * `Some(OffsetDateTime)` -> `Expiration::DateTime`
+///   * `OffsetDateTime` -> `Expiration::DateTime`
+///
+/// ```rust
+/// use cookie::Expiration;
+/// use time::OffsetDateTime;
+///
+/// let expires = Expiration::from(None);
+/// assert_eq!(expires, Expiration::Session);
+///
+/// let now = OffsetDateTime::now_utc();
+/// let expires = Expiration::from(now);
+/// assert_eq!(expires, Expiration::DateTime(now));
+///
+/// let expires = Expiration::from(Some(now));
+/// assert_eq!(expires, Expiration::DateTime(now));
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Expiration {
+    /// Expiration for a "permanent" cookie at a specific date-time.
+    DateTime(OffsetDateTime),
+    /// Expiration for a "session" cookie. Browsers define the notion of a
+    /// "session" and will automatically expire session cookies when they deem
+    /// the "session" to be over. This is typically, but need not be, when the
+    /// browser is closed.
+    Session,
+}
+
+impl Expiration {
+    /// Returns `true` if `self` is an `Expiration::DateTime`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Expiration;
+    /// use time::OffsetDateTime;
+    ///
+    /// let expires = Expiration::from(None);
+    /// assert!(!expires.is_datetime());
+    ///
+    /// let expires = Expiration::from(OffsetDateTime::now_utc());
+    /// assert!(expires.is_datetime());
+    /// ```
+    pub fn is_datetime(&self) -> bool {
+        match self {
+            Expiration::DateTime(_) => true,
+            Expiration::Session => false
+        }
+    }
+
+    /// Returns `true` if `self` is an `Expiration::Session`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Expiration;
+    /// use time::OffsetDateTime;
+    ///
+    /// let expires = Expiration::from(None);
+    /// assert!(expires.is_session());
+    ///
+    /// let expires = Expiration::from(OffsetDateTime::now_utc());
+    /// assert!(!expires.is_session());
+    /// ```
+    pub fn is_session(&self) -> bool {
+        match self {
+            Expiration::DateTime(_) => false,
+            Expiration::Session => true
+        }
+    }
+
+    /// Returns the inner `OffsetDateTime` if `self` is a `DateTime`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Expiration;
+    /// use time::OffsetDateTime;
+    ///
+    /// let expires = Expiration::from(None);
+    /// assert!(expires.datetime().is_none());
+    ///
+    /// let now = OffsetDateTime::now_utc();
+    /// let expires = Expiration::from(now);
+    /// assert_eq!(expires.datetime(), Some(now));
+    /// ```
+    pub fn datetime(self) -> Option<OffsetDateTime> {
+        match self {
+            Expiration::Session => None,
+            Expiration::DateTime(v) => Some(v)
+        }
+    }
+
+    /// Applied `f` to the inner `OffsetDateTime` if `self` is a `DateTime` and
+    /// returns the mapped `Expiration`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Expiration;
+    /// use time::{OffsetDateTime, Duration};
+    ///
+    /// let now = OffsetDateTime::now_utc();
+    /// let one_week = Duration::weeks(1);
+    ///
+    /// let expires = Expiration::from(now);
+    /// assert_eq!(expires.map(|t| t + one_week).datetime(), Some(now + one_week));
+    ///
+    /// let expires = Expiration::from(None);
+    /// assert_eq!(expires.map(|t| t + one_week).datetime(), None);
+    /// ```
+    pub fn map<F>(self, f: F) -> Self
+        where F: FnOnce(OffsetDateTime) -> OffsetDateTime
+    {
+        match self {
+            Expiration::Session => Expiration::Session,
+            Expiration::DateTime(v) => Expiration::DateTime(f(v)),
+        }
+    }
+}
+
+impl<T: Into<Option<OffsetDateTime>>> From<T> for Expiration {
+    fn from(option: T) -> Self {
+        match option.into() {
+            Some(value) => Expiration::DateTime(value),
+            None => Expiration::Session
+        }
+    }
+}
diff --git a/third_party/rust/cookie/src/jar.rs b/third_party/rust/cookie/src/jar.rs
new file mode 100644
index 0000000000..83f2a15fdc
--- /dev/null
+++ b/third_party/rust/cookie/src/jar.rs
@@ -0,0 +1,728 @@
+use std::collections::HashSet;
+
+#[cfg(feature = "signed")] use crate::secure::SignedJar;
+#[cfg(feature = "private")] use crate::secure::PrivateJar;
+#[cfg(any(feature = "signed", feature = "private"))] use crate::secure::Key;
+
+use crate::delta::DeltaCookie;
+use crate::Cookie;
+
+/// A collection of cookies that tracks its modifications.
+///
+/// A `CookieJar` provides storage for any number of cookies. Any changes made
+/// to the jar are tracked; the changes can be retrieved via the
+/// [delta](#method.delta) method which returns an iterator over the changes.
+///
+/// # Usage
+///
+/// A jar's life begins via [new](#method.new) and calls to
+/// [`add_original`](#method.add_original):
+///
+/// ```rust
+/// use cookie::{Cookie, CookieJar};
+///
+/// let mut jar = CookieJar::new();
+/// jar.add_original(Cookie::new("name", "value"));
+/// jar.add_original(Cookie::new("second", "another"));
+/// ```
+///
+/// Cookies can be added via [add](#method.add) and removed via
+/// [remove](#method.remove). Finally, cookies can be looked up via
+/// [get](#method.get):
+///
+/// ```rust
+/// # use cookie::{Cookie, CookieJar};
+/// let mut jar = CookieJar::new();
+/// jar.add(Cookie::new("a", "one"));
+/// jar.add(Cookie::new("b", "two"));
+///
+/// assert_eq!(jar.get("a").map(|c| c.value()), Some("one"));
+/// assert_eq!(jar.get("b").map(|c| c.value()), Some("two"));
+///
+/// jar.remove(Cookie::named("b"));
+/// assert!(jar.get("b").is_none());
+/// ```
+///
+/// # Deltas
+///
+/// A jar keeps track of any modifications made to it over time. The
+/// modifications are recorded as cookies. The modifications can be retrieved
+/// via [delta](#method.delta). Any new `Cookie` added to a jar via `add`
+/// results in the same `Cookie` appearing in the `delta`; cookies added via
+/// `add_original` do not count towards the delta. Any _original_ cookie that is
+/// removed from a jar results in a "removal" cookie appearing in the delta. A
+/// "removal" cookie is a cookie that a server sends so that the cookie is
+/// removed from the client's machine.
+///
+/// Deltas are typically used to create `Set-Cookie` headers corresponding to
+/// the changes made to a cookie jar over a period of time.
+///
+/// ```rust
+/// # use cookie::{Cookie, CookieJar};
+/// let mut jar = CookieJar::new();
+///
+/// // original cookies don't affect the delta
+/// jar.add_original(Cookie::new("original", "value"));
+/// assert_eq!(jar.delta().count(), 0);
+///
+/// // new cookies result in an equivalent `Cookie` in the delta
+/// jar.add(Cookie::new("a", "one"));
+/// jar.add(Cookie::new("b", "two"));
+/// assert_eq!(jar.delta().count(), 2);
+///
+/// // removing an original cookie adds a "removal" cookie to the delta
+/// jar.remove(Cookie::named("original"));
+/// assert_eq!(jar.delta().count(), 3);
+///
+/// // removing a new cookie that was added removes that `Cookie` from the delta
+/// jar.remove(Cookie::named("a"));
+/// assert_eq!(jar.delta().count(), 2);
+/// ```
+#[derive(Default, Debug, Clone)]
+pub struct CookieJar {
+    original_cookies: HashSet<DeltaCookie>,
+    delta_cookies: HashSet<DeltaCookie>,
+}
+
+impl CookieJar {
+    /// Creates an empty cookie jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::CookieJar;
+    ///
+    /// let jar = CookieJar::new();
+    /// assert_eq!(jar.iter().count(), 0);
+    /// ```
+    pub fn new() -> CookieJar {
+        CookieJar::default()
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name
+    /// `name`. If no such cookie exists, returns `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// assert!(jar.get("name").is_none());
+    ///
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// ```
+    pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
+        self.delta_cookies
+            .get(name)
+            .or_else(|| self.original_cookies.get(name))
+            .and_then(|c| if c.removed { None } else { Some(&c.cookie) })
+    }
+
+    /// Adds an "original" `cookie` to this jar. If an original cookie with the
+    /// same name already exists, it is replaced with `cookie`. Cookies added
+    /// with `add` take precedence and are not replaced by this method.
+    ///
+    /// Adding an original cookie does not affect the [delta](#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, cookie: Cookie<'static>) {
+        self.original_cookies.replace(DeltaCookie::added(cookie));
+    }
+
+    /// Adds `cookie` to this jar. If a cookie with the same name already
+    /// exists, it is replaced with `cookie`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("second", "two"));
+    ///
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 2);
+    /// ```
+    pub fn add(&mut self, cookie: Cookie<'static>) {
+        self.delta_cookies.replace(DeltaCookie::added(cookie));
+    }
+
+    /// Removes `cookie` from this jar. If an _original_ cookie with the same
+    /// name as `cookie` is present in the jar, a _removal_ cookie will be
+    /// present in the `delta` computation. To properly generate the removal
+    /// cookie, `cookie` must contain the same `path` and `domain` as the cookie
+    /// that was initially set.
+    ///
+    /// A "removal" cookie is a cookie that has the same name as the original
+    /// cookie but has an empty value, a max-age of 0, and an expiration date
+    /// far in the past. See also [`Cookie::make_removal()`].
+    ///
+    /// # Example
+    ///
+    /// Removing an _original_ cookie results in a _removal_ cookie:
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::{CookieJar, Cookie};
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Assume this cookie originally had a path of "/" and domain of "a.b".
+    /// jar.add_original(Cookie::new("name", "value"));
+    ///
+    /// // If the path and domain were set, they must be provided to `remove`.
+    /// jar.remove(Cookie::build("name", "").path("/").domain("a.b").finish());
+    ///
+    /// // The delta will contain the removal cookie.
+    /// let delta: Vec<_> = jar.delta().collect();
+    /// assert_eq!(delta.len(), 1);
+    /// assert_eq!(delta[0].name(), "name");
+    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
+    /// # }
+    /// ```
+    ///
+    /// Removing a new cookie does not result in a _removal_ cookie unless
+    /// there's an original cookie with the same name:
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// assert_eq!(jar.delta().count(), 0);
+    ///
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// ```
+    pub fn remove(&mut self, mut cookie: Cookie<'static>) {
+        if self.original_cookies.contains(cookie.name()) {
+            cookie.make_removal();
+            self.delta_cookies.replace(DeltaCookie::removed(cookie));
+        } else {
+            self.delta_cookies.remove(cookie.name());
+        }
+    }
+
+    /// Removes `cookie` from this jar completely. This method differs from
+    /// `remove` in that no delta cookie is created under any condition. Neither
+    /// the `delta` nor `iter` methods will return a cookie that is removed
+    /// using this method.
+    ///
+    /// # Example
+    ///
+    /// Removing an _original_ cookie; no _removal_ cookie is generated:
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::{CookieJar, Cookie};
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Add an original cookie and a new cookie.
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("key", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// assert_eq!(jar.iter().count(), 2);
+    ///
+    /// // Now force remove the original cookie.
+    /// jar.force_remove(&Cookie::named("name"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// assert_eq!(jar.iter().count(), 1);
+    ///
+    /// // Now force remove the new cookie.
+    /// jar.force_remove(&Cookie::named("key"));
+    /// assert_eq!(jar.delta().count(), 0);
+    /// assert_eq!(jar.iter().count(), 0);
+    /// # }
+    /// ```
+    pub fn force_remove<'a>(&mut self, cookie: &Cookie<'a>) {
+        self.original_cookies.remove(cookie.name());
+        self.delta_cookies.remove(cookie.name());
+    }
+
+    /// Removes all delta cookies, i.e. all cookies not added via
+    /// [`CookieJar::add_original()`], from this `CookieJar`. This undoes any
+    /// changes from [`CookieJar::add()`] and [`CookieJar::remove()`]
+    /// operations.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Only original cookies will remain after calling `reset_delta`.
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("language", "Rust"));
+    ///
+    /// // These operations, represented by delta cookies, will be reset.
+    /// jar.add(Cookie::new("language", "C++"));
+    /// jar.remove(Cookie::named("name"));
+    ///
+    /// // All is normal.
+    /// assert_eq!(jar.get("name"), None);
+    /// assert_eq!(jar.get("language").map(Cookie::value), Some("C++"));
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 2);
+    ///
+    /// // Resetting undoes delta operations.
+    /// jar.reset_delta();
+    /// assert_eq!(jar.get("name").map(Cookie::value), Some("value"));
+    /// assert_eq!(jar.get("language").map(Cookie::value), Some("Rust"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn reset_delta(&mut self) {
+        self.delta_cookies = HashSet::new();
+    }
+
+    /// Returns an iterator over cookies that represent the changes to this jar
+    /// over time. These cookies can be rendered directly as `Set-Cookie` header
+    /// values to affect the changes made to this jar on the client.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// // Add new cookies.
+    /// jar.add(Cookie::new("new", "third"));
+    /// jar.add(Cookie::new("another", "fourth"));
+    /// jar.add(Cookie::new("yac", "fifth"));
+    ///
+    /// // Remove some cookies.
+    /// jar.remove(Cookie::named("name"));
+    /// jar.remove(Cookie::named("another"));
+    ///
+    /// // Delta contains two new cookies ("new", "yac") and a removal ("name").
+    /// assert_eq!(jar.delta().count(), 3);
+    /// ```
+    pub fn delta(&self) -> Delta {
+        Delta { iter: self.delta_cookies.iter() }
+    }
+
+    /// Returns an iterator over all of the cookies present in this jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    ///
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// jar.add(Cookie::new("new", "third"));
+    /// jar.add(Cookie::new("another", "fourth"));
+    /// jar.add(Cookie::new("yac", "fifth"));
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// jar.remove(Cookie::named("another"));
+    ///
+    /// // There are three cookies in the jar: "second", "new", and "yac".
+    /// # assert_eq!(jar.iter().count(), 3);
+    /// for cookie in jar.iter() {
+    ///     match cookie.name() {
+    ///         "second" => assert_eq!(cookie.value(), "two"),
+    ///         "new" => assert_eq!(cookie.value(), "third"),
+    ///         "yac" => assert_eq!(cookie.value(), "fifth"),
+    ///         _ => unreachable!("there are only three cookies in the jar")
+    ///     }
+    /// }
+    /// ```
+    pub fn iter(&self) -> Iter {
+        Iter {
+            delta_cookies: self.delta_cookies.iter()
+                .chain(self.original_cookies.difference(&self.delta_cookies)),
+        }
+    }
+
+    /// Returns a read-only `PrivateJar` with `self` as its parent jar using the
+    /// key `key` to verify/decrypt cookies retrieved from the child jar. Any
+    /// retrievals from the child jar will be made from the parent jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a private (signed + encrypted) cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.private_mut(&key).add(Cookie::new("private", "text"));
+    ///
+    /// // The cookie's contents are encrypted.
+    /// assert_ne!(jar.get("private").unwrap().value(), "text");
+    ///
+    /// // They can be decrypted and verified through the child jar.
+    /// assert_eq!(jar.private(&key).get("private").unwrap().value(), "text");
+    ///
+    /// // A tampered with cookie does not validate but still exists.
+    /// let mut cookie = jar.get("private").unwrap().clone();
+    /// jar.add(Cookie::new("private", cookie.value().to_string() + "!"));
+    /// assert!(jar.private(&key).get("private").is_none());
+    /// assert!(jar.get("private").is_some());
+    /// ```
+    #[cfg(feature = "private")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "private")))]
+    pub fn private<'a>(&'a self, key: &Key) -> PrivateJar<&'a Self> {
+        PrivateJar::new(self, key)
+    }
+
+    /// Returns a read/write `PrivateJar` with `self` as its parent jar using
+    /// the key `key` to sign/encrypt and verify/decrypt cookies added/retrieved
+    /// from the child jar.
+    ///
+    /// Any modifications to the child jar will be reflected on the parent jar,
+    /// and any retrievals from the child jar will be made from the parent jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a private (signed + encrypted) cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.private_mut(&key).add(Cookie::new("private", "text"));
+    ///
+    /// // Remove a cookie using the child jar.
+    /// jar.private_mut(&key).remove(Cookie::named("private"));
+    /// ```
+    #[cfg(feature = "private")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "private")))]
+    pub fn private_mut<'a>(&'a mut self, key: &Key) -> PrivateJar<&'a mut Self> {
+        PrivateJar::new(self, key)
+    }
+
+    /// Returns a read-only `SignedJar` with `self` as its parent jar using the
+    /// key `key` to verify cookies retrieved from the child jar. Any retrievals
+    /// from the child jar will be made from the parent jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a signed cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.signed_mut(&key).add(Cookie::new("signed", "text"));
+    ///
+    /// // The cookie's contents are signed but still in plaintext.
+    /// assert_ne!(jar.get("signed").unwrap().value(), "text");
+    /// assert!(jar.get("signed").unwrap().value().contains("text"));
+    ///
+    /// // They can be verified through the child jar.
+    /// assert_eq!(jar.signed(&key).get("signed").unwrap().value(), "text");
+    ///
+    /// // A tampered with cookie does not validate but still exists.
+    /// let mut cookie = jar.get("signed").unwrap().clone();
+    /// jar.add(Cookie::new("signed", cookie.value().to_string() + "!"));
+    /// assert!(jar.signed(&key).get("signed").is_none());
+    /// assert!(jar.get("signed").is_some());
+    /// ```
+    #[cfg(feature = "signed")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "signed")))]
+    pub fn signed<'a>(&'a self, key: &Key) -> SignedJar<&'a Self> {
+        SignedJar::new(self, key)
+    }
+
+    /// Returns a read/write `SignedJar` with `self` as its parent jar using the
+    /// key `key` to sign/verify cookies added/retrieved from the child jar.
+    ///
+    /// Any modifications to the child jar will be reflected on the parent jar,
+    /// and any retrievals from the child jar will be made from the parent jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a signed cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.signed_mut(&key).add(Cookie::new("signed", "text"));
+    ///
+    /// // Remove a cookie.
+    /// jar.signed_mut(&key).remove(Cookie::named("signed"));
+    /// ```
+    #[cfg(feature = "signed")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "signed")))]
+    pub fn signed_mut<'a>(&'a mut self, key: &Key) -> SignedJar<&'a mut Self> {
+        SignedJar::new(self, key)
+    }
+}
+
+use std::collections::hash_set::Iter as HashSetIter;
+
+/// Iterator over the changes to a cookie jar.
+pub struct Delta<'a> {
+    iter: HashSetIter<'a, DeltaCookie>,
+}
+
+impl<'a> Iterator for Delta<'a> {
+    type Item = &'a Cookie<'static>;
+
+    fn next(&mut self) -> Option<&'a Cookie<'static>> {
+        self.iter.next().map(|c| &c.cookie)
+    }
+}
+
+use std::collections::hash_set::Difference;
+use std::collections::hash_map::RandomState;
+use std::iter::Chain;
+
+/// Iterator over all of the cookies in a jar.
+pub struct Iter<'a> {
+    delta_cookies: Chain<HashSetIter<'a, DeltaCookie>, Difference<'a, DeltaCookie, RandomState>>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a Cookie<'static>;
+
+    fn next(&mut self) -> Option<&'a Cookie<'static>> {
+        for cookie in self.delta_cookies.by_ref() {
+            if !cookie.removed {
+                return Some(&*cookie);
+            }
+        }
+
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::CookieJar;
+    use crate::Cookie;
+
+    #[test]
+    #[allow(deprecated)]
+    fn simple() {
+        let mut c = CookieJar::new();
+
+        c.add(Cookie::new("test", ""));
+        c.add(Cookie::new("test2", ""));
+        c.remove(Cookie::named("test"));
+
+        assert!(c.get("test").is_none());
+        assert!(c.get("test2").is_some());
+
+        c.add(Cookie::new("test3", ""));
+        c.remove(Cookie::named("test2"));
+        c.remove(Cookie::named("test3"));
+
+        assert!(c.get("test").is_none());
+        assert!(c.get("test2").is_none());
+        assert!(c.get("test3").is_none());
+    }
+
+    #[test]
+    fn jar_is_send() {
+        fn is_send<T: Send>(_: T) -> bool {
+            true
+        }
+
+        assert!(is_send(CookieJar::new()))
+    }
+
+    #[test]
+    #[cfg(all(feature = "signed", feature = "private"))]
+    fn iter() {
+        let key = crate::Key::generate();
+        let mut c = CookieJar::new();
+
+        c.add_original(Cookie::new("original", "original"));
+
+        c.add(Cookie::new("test", "test"));
+        c.add(Cookie::new("test2", "test2"));
+        c.add(Cookie::new("test3", "test3"));
+        assert_eq!(c.iter().count(), 4);
+
+        c.signed_mut(&key).add(Cookie::new("signed", "signed"));
+        c.private_mut(&key).add(Cookie::new("encrypted", "encrypted"));
+        assert_eq!(c.iter().count(), 6);
+
+        c.remove(Cookie::named("test"));
+        assert_eq!(c.iter().count(), 5);
+
+        c.remove(Cookie::named("signed"));
+        c.remove(Cookie::named("test2"));
+        assert_eq!(c.iter().count(), 3);
+
+        c.add(Cookie::new("test2", "test2"));
+        assert_eq!(c.iter().count(), 4);
+
+        c.remove(Cookie::named("test2"));
+        assert_eq!(c.iter().count(), 3);
+    }
+
+    #[test]
+    fn delta() {
+        use std::collections::HashMap;
+        use time::Duration;
+
+        let mut c = CookieJar::new();
+
+        c.add_original(Cookie::new("original", "original"));
+        c.add_original(Cookie::new("original1", "original1"));
+
+        c.add(Cookie::new("test", "test"));
+        c.add(Cookie::new("test2", "test2"));
+        c.add(Cookie::new("test3", "test3"));
+        c.add(Cookie::new("test4", "test4"));
+
+        c.remove(Cookie::named("test"));
+        c.remove(Cookie::named("original"));
+
+        assert_eq!(c.delta().count(), 4);
+
+        let names: HashMap<_, _> = c.delta()
+            .map(|c| (c.name(), c.max_age()))
+            .collect();
+
+        assert!(names.get("test2").unwrap().is_none());
+        assert!(names.get("test3").unwrap().is_none());
+        assert!(names.get("test4").unwrap().is_none());
+        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
+    }
+
+    #[test]
+    fn replace_original() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("original_a", "a"));
+        jar.add_original(Cookie::new("original_b", "b"));
+        assert_eq!(jar.get("original_a").unwrap().value(), "a");
+
+        jar.add(Cookie::new("original_a", "av2"));
+        assert_eq!(jar.get("original_a").unwrap().value(), "av2");
+    }
+
+    #[test]
+    fn empty_delta() {
+        let mut jar = CookieJar::new();
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 1);
+    }
+
+    #[test]
+    fn add_remove_add() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        // The cookie's been deleted. Another original doesn't change that.
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+    }
+
+    #[test]
+    fn replace_remove() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+    }
+
+    #[test]
+    fn remove_with_path() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::build("name", "val").finish());
+        assert_eq!(jar.iter().count(), 1);
+        assert_eq!(jar.delta().count(), 0);
+        assert_eq!(jar.iter().filter(|c| c.path().is_none()).count(), 1);
+
+        jar.remove(Cookie::build("name", "").path("/").finish());
+        assert_eq!(jar.iter().count(), 0);
+        assert_eq!(jar.delta().count(), 1);
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().filter(|c| c.path() == Some("/")).count(), 1);
+    }
+}
diff --git a/third_party/rust/cookie/src/lib.rs b/third_party/rust/cookie/src/lib.rs
new file mode 100644
index 0000000000..392728efbc
--- /dev/null
+++ b/third_party/rust/cookie/src/lib.rs
@@ -0,0 +1,1422 @@
+//! HTTP cookie parsing and cookie jar management.
+//!
+//! This crates provides the [`Cookie`] type, representing an HTTP cookie, and
+//! the [`CookieJar`] type, which manages a collection of cookies for session
+//! management, recording changes as they are made, and optional automatic
+//! cookie encryption and signing.
+//!
+//! # Usage
+//!
+//! Add the following to the `[dependencies]` section of your `Cargo.toml`:
+//!
+//! ```toml
+//! cookie = "0.16"
+//! ```
+//!
+//! # Features
+//!
+//! This crate exposes several features, all of which are disabled by default:
+//!
+//! * **`percent-encode`**
+//!
+//!   Enables _percent encoding and decoding_ of names and values in cookies.
+//!
+//!   When this feature is enabled, the [`Cookie::encoded()`] and
+//!   [`Cookie::parse_encoded()`] methods are available. The `encoded` method
+//!   returns a wrapper around a `Cookie` whose `Display` implementation
+//!   percent-encodes the name and value of the cookie. The `parse_encoded`
+//!   method percent-decodes the name and value of a `Cookie` during parsing.
+//!
+//! * **`signed`**
+//!
+//!   Enables _signed_ cookies via [`CookieJar::signed()`].
+//!
+//!   When this feature is enabled, the [`CookieJar::signed()`] method,
+//!   [`SignedJar`] type, and [`Key`] type are available. The jar acts as "child
+//!   jar"; operations on the jar automatically sign and verify cookies as they
+//!   are added and retrieved from the parent jar.
+//!
+//! * **`private`**
+//!
+//!   Enables _private_ (authenticated, encrypted) cookies via
+//!   [`CookieJar::private()`].
+//!
+//!   When this feature is enabled, the [`CookieJar::private()`] method,
+//!   [`PrivateJar`] type, and [`Key`] type are available. The jar acts as "child
+//!   jar"; operations on the jar automatically encrypt and decrypt/authenticate
+//!   cookies as they are added and retrieved from the parent jar.
+//!
+//! * **`key-expansion`**
+//!
+//!   Enables _key expansion_ or _key derivation_ via [`Key::derive_from()`].
+//!
+//!   When this feature is enabled, and either `signed` or `private` are _also_
+//!   enabled, the [`Key::derive_from()`] method is available. The method can be
+//!   used to derive a `Key` structure appropriate for use with signed and
+//!   private jars from cryptographically valid key material that is shorter in
+//!   length than the full key.
+//!
+//! * **`secure`**
+//!
+//!   A meta-feature that simultaneously enables `signed`, `private`, and
+//!   `key-expansion`.
+//!
+//! You can enable features via `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies.cookie]
+//! features = ["secure", "percent-encode"]
+//! ```
+
+#![cfg_attr(all(nightly, doc), feature(doc_cfg))]
+
+#![doc(html_root_url = "https://docs.rs/cookie/0.16")]
+#![deny(missing_docs)]
+
+pub use time;
+
+mod builder;
+mod parse;
+mod jar;
+mod delta;
+mod draft;
+mod expiration;
+
+#[cfg(any(feature = "private", feature = "signed"))] #[macro_use] mod secure;
+#[cfg(any(feature = "private", feature = "signed"))] pub use secure::*;
+
+use std::borrow::Cow;
+use std::fmt;
+use std::str::FromStr;
+
+#[allow(unused_imports, deprecated)]
+use std::ascii::AsciiExt;
+
+use time::{Duration, OffsetDateTime, UtcOffset, macros::datetime};
+
+use crate::parse::parse_cookie;
+pub use crate::parse::ParseError;
+pub use crate::builder::CookieBuilder;
+pub use crate::jar::{CookieJar, Delta, Iter};
+pub use crate::draft::*;
+pub use crate::expiration::*;
+
+#[derive(Debug, Clone)]
+enum CookieStr<'c> {
+    /// An string derived from indexes (start, end).
+    Indexed(usize, usize),
+    /// A string derived from a concrete string.
+    Concrete(Cow<'c, str>),
+}
+
+impl<'c> CookieStr<'c> {
+    /// Retrieves the string `self` corresponds to. If `self` is derived from
+    /// indexes, the corresponding subslice of `string` is returned. Otherwise,
+    /// the concrete string is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is an indexed string and `string` is None.
+    fn to_str<'s>(&'s self, string: Option<&'s Cow<str>>) -> &'s str {
+        match *self {
+            CookieStr::Indexed(i, j) => {
+                let s = string.expect("`Some` base string must exist when \
+                    converting indexed str to str! (This is a module invariant.)");
+                &s[i..j]
+            },
+            CookieStr::Concrete(ref cstr) => &*cstr,
+        }
+    }
+
+    #[allow(clippy::ptr_arg)]
+    fn to_raw_str<'s, 'b: 's>(&'s self, string: &'s Cow<'b, str>) -> Option<&'b str> {
+        match *self {
+            CookieStr::Indexed(i, j) => {
+                match *string {
+                    Cow::Borrowed(s) => Some(&s[i..j]),
+                    Cow::Owned(_) => None,
+                }
+            },
+            CookieStr::Concrete(_) => None,
+        }
+    }
+
+    fn into_owned(self) -> CookieStr<'static> {
+        use crate::CookieStr::*;
+
+        match self {
+            Indexed(a, b) => Indexed(a, b),
+            Concrete(Cow::Owned(c)) => Concrete(Cow::Owned(c)),
+            Concrete(Cow::Borrowed(c)) => Concrete(Cow::Owned(c.into())),
+        }
+    }
+}
+
+/// Representation of an HTTP cookie.
+///
+/// # Constructing a `Cookie`
+///
+/// To construct a cookie with only a name/value, use [`Cookie::new()`]:
+///
+/// ```rust
+/// use cookie::Cookie;
+///
+/// let cookie = Cookie::new("name", "value");
+/// assert_eq!(&cookie.to_string(), "name=value");
+/// ```
+///
+/// To construct more elaborate cookies, use [`Cookie::build()`] and
+/// [`CookieBuilder`] methods:
+///
+/// ```rust
+/// use cookie::Cookie;
+///
+/// let cookie = Cookie::build("name", "value")
+///     .domain("www.rust-lang.org")
+///     .path("/")
+///     .secure(true)
+///     .http_only(true)
+///     .finish();
+/// ```
+#[derive(Debug, Clone)]
+pub struct Cookie<'c> {
+    /// Storage for the cookie string. Only used if this structure was derived
+    /// from a string that was subsequently parsed.
+    cookie_string: Option<Cow<'c, str>>,
+    /// The cookie's name.
+    name: CookieStr<'c>,
+    /// The cookie's value.
+    value: CookieStr<'c>,
+    /// The cookie's expiration, if any.
+    expires: Option<Expiration>,
+    /// The cookie's maximum age, if any.
+    max_age: Option<Duration>,
+    /// The cookie's domain, if any.
+    domain: Option<CookieStr<'c>>,
+    /// The cookie's path domain, if any.
+    path: Option<CookieStr<'c>>,
+    /// Whether this cookie was marked Secure.
+    secure: Option<bool>,
+    /// Whether this cookie was marked HttpOnly.
+    http_only: Option<bool>,
+    /// The draft `SameSite` attribute.
+    same_site: Option<SameSite>,
+}
+
+impl<'c> Cookie<'c> {
+    /// Creates a new `Cookie` with the given name and value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let cookie = Cookie::new("name", "value");
+    /// assert_eq!(cookie.name_value(), ("name", "value"));
+    /// ```
+    pub fn new<N, V>(name: N, value: V) -> Self
+        where N: Into<Cow<'c, str>>,
+              V: Into<Cow<'c, str>>
+    {
+        Cookie {
+            cookie_string: None,
+            name: CookieStr::Concrete(name.into()),
+            value: CookieStr::Concrete(value.into()),
+            expires: None,
+            max_age: None,
+            domain: None,
+            path: None,
+            secure: None,
+            http_only: None,
+            same_site: None,
+        }
+    }
+
+    /// Creates a new `Cookie` with the given name and an empty value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let cookie = Cookie::named("name");
+    /// assert_eq!(cookie.name(), "name");
+    /// assert!(cookie.value().is_empty());
+    /// ```
+    pub fn named<N>(name: N) -> Cookie<'c>
+        where N: Into<Cow<'c, str>>
+    {
+        Cookie::new(name, "")
+    }
+
+    /// Creates a new `CookieBuilder` instance from the given key and value
+    /// strings.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar").finish();
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// ```
+    pub fn build<N, V>(name: N, value: V) -> CookieBuilder<'c>
+        where N: Into<Cow<'c, str>>,
+              V: Into<Cow<'c, str>>
+    {
+        CookieBuilder::new(name, value)
+    }
+
+    /// Parses a `Cookie` from the given HTTP cookie header value string. Does
+    /// not perform any percent-decoding.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("foo=bar%20baz; HttpOnly").unwrap();
+    /// assert_eq!(c.name_value(), ("foo", "bar%20baz"));
+    /// assert_eq!(c.http_only(), Some(true));
+    /// ```
+    pub fn parse<S>(s: S) -> Result<Cookie<'c>, ParseError>
+        where S: Into<Cow<'c, str>>
+    {
+        parse_cookie(s, false)
+    }
+
+    /// Parses a `Cookie` from the given HTTP cookie header value string where
+    /// the name and value fields are percent-encoded. Percent-decodes the
+    /// name/value fields.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse_encoded("foo=bar%20baz; HttpOnly").unwrap();
+    /// assert_eq!(c.name_value(), ("foo", "bar baz"));
+    /// assert_eq!(c.http_only(), Some(true));
+    /// ```
+    #[cfg(feature = "percent-encode")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "percent-encode")))]
+    pub fn parse_encoded<S>(s: S) -> Result<Cookie<'c>, ParseError>
+        where S: Into<Cow<'c, str>>
+    {
+        parse_cookie(s, true)
+    }
+
+    /// Converts `self` into a `Cookie` with a static lifetime with as few
+    /// allocations as possible.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::new("a", "b");
+    /// let owned_cookie = c.into_owned();
+    /// assert_eq!(owned_cookie.name_value(), ("a", "b"));
+    /// ```
+    pub fn into_owned(self) -> Cookie<'static> {
+        Cookie {
+            cookie_string: self.cookie_string.map(|s| s.into_owned().into()),
+            name: self.name.into_owned(),
+            value: self.value.into_owned(),
+            expires: self.expires,
+            max_age: self.max_age,
+            domain: self.domain.map(|s| s.into_owned()),
+            path: self.path.map(|s| s.into_owned()),
+            secure: self.secure,
+            http_only: self.http_only,
+            same_site: self.same_site,
+        }
+    }
+
+    /// Returns the name of `self`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::new("name", "value");
+    /// assert_eq!(c.name(), "name");
+    /// ```
+    #[inline]
+    pub fn name(&self) -> &str {
+        self.name.to_str(self.cookie_string.as_ref())
+    }
+
+    /// Returns the value of `self`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::new("name", "value");
+    /// assert_eq!(c.value(), "value");
+    /// ```
+    #[inline]
+    pub fn value(&self) -> &str {
+        self.value.to_str(self.cookie_string.as_ref())
+    }
+
+    /// Returns the name and value of `self` as a tuple of `(name, value)`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::new("name", "value");
+    /// assert_eq!(c.name_value(), ("name", "value"));
+    /// ```
+    #[inline]
+    pub fn name_value(&self) -> (&str, &str) {
+        (self.name(), self.value())
+    }
+
+    /// Returns whether this cookie was marked `HttpOnly` or not. Returns
+    /// `Some(true)` when the cookie was explicitly set (manually or parsed) as
+    /// `HttpOnly`, `Some(false)` when `http_only` was manually set to `false`,
+    /// and `None` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("name=value; httponly").unwrap();
+    /// assert_eq!(c.http_only(), Some(true));
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.http_only(), None);
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.http_only(), None);
+    ///
+    /// // An explicitly set "false" value.
+    /// c.set_http_only(false);
+    /// assert_eq!(c.http_only(), Some(false));
+    ///
+    /// // An explicitly set "true" value.
+    /// c.set_http_only(true);
+    /// assert_eq!(c.http_only(), Some(true));
+    /// ```
+    #[inline]
+    pub fn http_only(&self) -> Option<bool> {
+        self.http_only
+    }
+
+    /// Returns whether this cookie was marked `Secure` or not. Returns
+    /// `Some(true)` when the cookie was explicitly set (manually or parsed) as
+    /// `Secure`, `Some(false)` when `secure` was manually set to `false`, and
+    /// `None` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("name=value; Secure").unwrap();
+    /// assert_eq!(c.secure(), Some(true));
+    ///
+    /// let mut c = Cookie::parse("name=value").unwrap();
+    /// assert_eq!(c.secure(), None);
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.secure(), None);
+    ///
+    /// // An explicitly set "false" value.
+    /// c.set_secure(false);
+    /// assert_eq!(c.secure(), Some(false));
+    ///
+    /// // An explicitly set "true" value.
+    /// c.set_secure(true);
+    /// assert_eq!(c.secure(), Some(true));
+    /// ```
+    #[inline]
+    pub fn secure(&self) -> Option<bool> {
+        self.secure
+    }
+
+    /// Returns the `SameSite` attribute of this cookie if one was specified.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::{Cookie, SameSite};
+    ///
+    /// let c = Cookie::parse("name=value; SameSite=Lax").unwrap();
+    /// assert_eq!(c.same_site(), Some(SameSite::Lax));
+    /// ```
+    #[inline]
+    pub fn same_site(&self) -> Option<SameSite> {
+        self.same_site
+    }
+
+    /// Returns the specified max-age of the cookie if one was specified.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("name=value").unwrap();
+    /// assert_eq!(c.max_age(), None);
+    ///
+    /// let c = Cookie::parse("name=value; Max-Age=3600").unwrap();
+    /// assert_eq!(c.max_age().map(|age| age.whole_hours()), Some(1));
+    /// ```
+    #[inline]
+    pub fn max_age(&self) -> Option<Duration> {
+        self.max_age
+    }
+
+    /// Returns the `Path` of the cookie if one was specified.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("name=value").unwrap();
+    /// assert_eq!(c.path(), None);
+    ///
+    /// let c = Cookie::parse("name=value; Path=/").unwrap();
+    /// assert_eq!(c.path(), Some("/"));
+    ///
+    /// let c = Cookie::parse("name=value; path=/sub").unwrap();
+    /// assert_eq!(c.path(), Some("/sub"));
+    /// ```
+    #[inline]
+    pub fn path(&self) -> Option<&str> {
+        match self.path {
+            Some(ref c) => Some(c.to_str(self.cookie_string.as_ref())),
+            None => None,
+        }
+    }
+
+    /// Returns the `Domain` of the cookie if one was specified.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("name=value").unwrap();
+    /// assert_eq!(c.domain(), None);
+    ///
+    /// let c = Cookie::parse("name=value; Domain=crates.io").unwrap();
+    /// assert_eq!(c.domain(), Some("crates.io"));
+    /// ```
+    #[inline]
+    pub fn domain(&self) -> Option<&str> {
+        match self.domain {
+            Some(ref c) => Some(c.to_str(self.cookie_string.as_ref())),
+            None => None,
+        }
+    }
+
+    /// Returns the [`Expiration`] of the cookie if one was specified.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::{Cookie, Expiration};
+    ///
+    /// let c = Cookie::parse("name=value").unwrap();
+    /// assert_eq!(c.expires(), None);
+    ///
+    /// // Here, `cookie.expires_datetime()` returns `None`.
+    /// let c = Cookie::build("name", "value").expires(None).finish();
+    /// assert_eq!(c.expires(), Some(Expiration::Session));
+    ///
+    /// let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
+    /// let cookie_str = format!("name=value; Expires={}", expire_time);
+    /// let c = Cookie::parse(cookie_str).unwrap();
+    /// assert_eq!(c.expires().and_then(|e| e.datetime()).map(|t| t.year()), Some(2017));
+    /// ```
+    #[inline]
+    pub fn expires(&self) -> Option<Expiration> {
+        self.expires
+    }
+
+    /// Returns the expiration date-time of the cookie if one was specified.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let c = Cookie::parse("name=value").unwrap();
+    /// assert_eq!(c.expires_datetime(), None);
+    ///
+    /// // Here, `cookie.expires()` returns `Some`.
+    /// let c = Cookie::build("name", "value").expires(None).finish();
+    /// assert_eq!(c.expires_datetime(), None);
+    ///
+    /// let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
+    /// let cookie_str = format!("name=value; Expires={}", expire_time);
+    /// let c = Cookie::parse(cookie_str).unwrap();
+    /// assert_eq!(c.expires_datetime().map(|t| t.year()), Some(2017));
+    /// ```
+    #[inline]
+    pub fn expires_datetime(&self) -> Option<OffsetDateTime> {
+        self.expires.and_then(|e| e.datetime())
+    }
+
+    /// Sets the name of `self` to `name`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.name(), "name");
+    ///
+    /// c.set_name("foo");
+    /// assert_eq!(c.name(), "foo");
+    /// ```
+    pub fn set_name<N: Into<Cow<'c, str>>>(&mut self, name: N) {
+        self.name = CookieStr::Concrete(name.into())
+    }
+
+    /// Sets the value of `self` to `value`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.value(), "value");
+    ///
+    /// c.set_value("bar");
+    /// assert_eq!(c.value(), "bar");
+    /// ```
+    pub fn set_value<V: Into<Cow<'c, str>>>(&mut self, value: V) {
+        self.value = CookieStr::Concrete(value.into())
+    }
+
+    /// Sets the value of `http_only` in `self` to `value`.  If `value` is
+    /// `None`, the field is unset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.http_only(), None);
+    ///
+    /// c.set_http_only(true);
+    /// assert_eq!(c.http_only(), Some(true));
+    ///
+    /// c.set_http_only(false);
+    /// assert_eq!(c.http_only(), Some(false));
+    ///
+    /// c.set_http_only(None);
+    /// assert_eq!(c.http_only(), None);
+    /// ```
+    #[inline]
+    pub fn set_http_only<T: Into<Option<bool>>>(&mut self, value: T) {
+        self.http_only = value.into();
+    }
+
+    /// Sets the value of `secure` in `self` to `value`. If `value` is `None`,
+    /// the field is unset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.secure(), None);
+    ///
+    /// c.set_secure(true);
+    /// assert_eq!(c.secure(), Some(true));
+    ///
+    /// c.set_secure(false);
+    /// assert_eq!(c.secure(), Some(false));
+    ///
+    /// c.set_secure(None);
+    /// assert_eq!(c.secure(), None);
+    /// ```
+    #[inline]
+    pub fn set_secure<T: Into<Option<bool>>>(&mut self, value: T) {
+        self.secure = value.into();
+    }
+
+    /// Sets the value of `same_site` in `self` to `value`. If `value` is
+    /// `None`, the field is unset. If `value` is `SameSite::None`, the "Secure"
+    /// flag will be set when the cookie is written out unless `secure` is
+    /// explicitly set to `false` via [`Cookie::set_secure()`] or the equivalent
+    /// builder method.
+    ///
+    /// [HTTP draft]: https://tools.ietf.org/html/draft-west-cookie-incrementalism-00
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::{Cookie, SameSite};
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.same_site(), None);
+    ///
+    /// c.set_same_site(SameSite::None);
+    /// assert_eq!(c.same_site(), Some(SameSite::None));
+    /// assert_eq!(c.to_string(), "name=value; SameSite=None; Secure");
+    ///
+    /// c.set_secure(false);
+    /// assert_eq!(c.to_string(), "name=value; SameSite=None");
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.same_site(), None);
+    ///
+    /// c.set_same_site(SameSite::Strict);
+    /// assert_eq!(c.same_site(), Some(SameSite::Strict));
+    /// assert_eq!(c.to_string(), "name=value; SameSite=Strict");
+    ///
+    /// c.set_same_site(None);
+    /// assert_eq!(c.same_site(), None);
+    /// assert_eq!(c.to_string(), "name=value");
+    /// ```
+    #[inline]
+    pub fn set_same_site<T: Into<Option<SameSite>>>(&mut self, value: T) {
+        self.same_site = value.into();
+    }
+
+    /// Sets the value of `max_age` in `self` to `value`. If `value` is `None`,
+    /// the field is unset.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::Cookie;
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.max_age(), None);
+    ///
+    /// c.set_max_age(Duration::hours(10));
+    /// assert_eq!(c.max_age(), Some(Duration::hours(10)));
+    ///
+    /// c.set_max_age(None);
+    /// assert!(c.max_age().is_none());
+    /// # }
+    /// ```
+    #[inline]
+    pub fn set_max_age<D: Into<Option<Duration>>>(&mut self, value: D) {
+        self.max_age = value.into();
+    }
+
+    /// Sets the `path` of `self` to `path`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.path(), None);
+    ///
+    /// c.set_path("/");
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    pub fn set_path<P: Into<Cow<'c, str>>>(&mut self, path: P) {
+        self.path = Some(CookieStr::Concrete(path.into()));
+    }
+
+    /// Unsets the `path` of `self`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.path(), None);
+    ///
+    /// c.set_path("/");
+    /// assert_eq!(c.path(), Some("/"));
+    ///
+    /// c.unset_path();
+    /// assert_eq!(c.path(), None);
+    /// ```
+    pub fn unset_path(&mut self) {
+        self.path = None;
+    }
+
+    /// Sets the `domain` of `self` to `domain`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.domain(), None);
+    ///
+    /// c.set_domain("rust-lang.org");
+    /// assert_eq!(c.domain(), Some("rust-lang.org"));
+    /// ```
+    pub fn set_domain<D: Into<Cow<'c, str>>>(&mut self, domain: D) {
+        self.domain = Some(CookieStr::Concrete(domain.into()));
+    }
+
+    /// Unsets the `domain` of `self`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.domain(), None);
+    ///
+    /// c.set_domain("rust-lang.org");
+    /// assert_eq!(c.domain(), Some("rust-lang.org"));
+    ///
+    /// c.unset_domain();
+    /// assert_eq!(c.domain(), None);
+    /// ```
+    pub fn unset_domain(&mut self) {
+        self.domain = None;
+    }
+
+    /// Sets the expires field of `self` to `time`. If `time` is `None`, an
+    /// expiration of [`Session`](Expiration::Session) is set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # extern crate cookie;
+    /// use cookie::{Cookie, Expiration};
+    /// use cookie::time::{Duration, OffsetDateTime};
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.expires(), None);
+    ///
+    /// let mut now = OffsetDateTime::now_utc();
+    /// now += Duration::weeks(52);
+    ///
+    /// c.set_expires(now);
+    /// assert!(c.expires().is_some());
+    ///
+    /// c.set_expires(None);
+    /// assert_eq!(c.expires(), Some(Expiration::Session));
+    /// ```
+    pub fn set_expires<T: Into<Expiration>>(&mut self, time: T) {
+        static MAX_DATETIME: OffsetDateTime = datetime!(9999-12-31 23:59:59.999_999 UTC);
+
+        // RFC 6265 requires dates not to exceed 9999 years.
+        self.expires = Some(time.into()
+            .map(|time| std::cmp::min(time, MAX_DATETIME)));
+    }
+
+    /// Unsets the `expires` of `self`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::{Cookie, Expiration};
+    ///
+    /// let mut c = Cookie::new("name", "value");
+    /// assert_eq!(c.expires(), None);
+    ///
+    /// c.set_expires(None);
+    /// assert_eq!(c.expires(), Some(Expiration::Session));
+    ///
+    /// c.unset_expires();
+    /// assert_eq!(c.expires(), None);
+    /// ```
+    pub fn unset_expires(&mut self) {
+        self.expires = None;
+    }
+
+    /// Makes `self` a "permanent" cookie by extending its expiration and max
+    /// age 20 years into the future.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::Cookie;
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let mut c = Cookie::new("foo", "bar");
+    /// assert!(c.expires().is_none());
+    /// assert!(c.max_age().is_none());
+    ///
+    /// c.make_permanent();
+    /// assert!(c.expires().is_some());
+    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
+    /// # }
+    /// ```
+    pub fn make_permanent(&mut self) {
+        let twenty_years = Duration::days(365 * 20);
+        self.set_max_age(twenty_years);
+        self.set_expires(OffsetDateTime::now_utc() + twenty_years);
+    }
+
+    /// Make `self` a "removal" cookie by clearing its value, setting a max-age
+    /// of `0`, and setting an expiration date far in the past.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # extern crate cookie;
+    /// use cookie::Cookie;
+    /// use cookie::time::Duration;
+    ///
+    /// # fn main() {
+    /// let mut c = Cookie::new("foo", "bar");
+    /// c.make_permanent();
+    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
+    /// assert_eq!(c.value(), "bar");
+    ///
+    /// c.make_removal();
+    /// assert_eq!(c.value(), "");
+    /// assert_eq!(c.max_age(), Some(Duration::ZERO));
+    /// # }
+    /// ```
+    pub fn make_removal(&mut self) {
+        self.set_value("");
+        self.set_max_age(Duration::seconds(0));
+        self.set_expires(OffsetDateTime::now_utc() - Duration::days(365));
+    }
+
+    fn fmt_parameters(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(true) = self.http_only() {
+            write!(f, "; HttpOnly")?;
+        }
+
+        if let Some(same_site) = self.same_site() {
+            write!(f, "; SameSite={}", same_site)?;
+
+            if same_site.is_none() && self.secure().is_none() {
+                write!(f, "; Secure")?;
+            }
+        }
+
+        if let Some(true) = self.secure() {
+            write!(f, "; Secure")?;
+        }
+
+        if let Some(path) = self.path() {
+            write!(f, "; Path={}", path)?;
+        }
+
+        if let Some(domain) = self.domain() {
+            write!(f, "; Domain={}", domain)?;
+        }
+
+        if let Some(max_age) = self.max_age() {
+            write!(f, "; Max-Age={}", max_age.whole_seconds())?;
+        }
+
+        if let Some(time) = self.expires_datetime() {
+            let time = time.to_offset(UtcOffset::UTC);
+            write!(f, "; Expires={}", time.format(&crate::parse::FMT1).map_err(|_| fmt::Error)?)?;
+        }
+
+        Ok(())
+    }
+
+    /// Returns the name of `self` as a string slice of the raw string `self`
+    /// was originally parsed from. If `self` was not originally parsed from a
+    /// raw string, returns `None`.
+    ///
+    /// This method differs from [`Cookie::name()`] in that it returns a string
+    /// with the same lifetime as the originally parsed string. This lifetime
+    /// may outlive `self`. If a longer lifetime is not required, or you're
+    /// unsure if you need a longer lifetime, use [`Cookie::name()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let cookie_string = format!("{}={}", "foo", "bar");
+    ///
+    /// // `c` will be dropped at the end of the scope, but `name` will live on
+    /// let name = {
+    ///     let c = Cookie::parse(cookie_string.as_str()).unwrap();
+    ///     c.name_raw()
+    /// };
+    ///
+    /// assert_eq!(name, Some("foo"));
+    /// ```
+    #[inline]
+    pub fn name_raw(&self) -> Option<&'c str> {
+        self.cookie_string.as_ref()
+            .and_then(|s| self.name.to_raw_str(s))
+    }
+
+    /// Returns the value of `self` as a string slice of the raw string `self`
+    /// was originally parsed from. If `self` was not originally parsed from a
+    /// raw string, returns `None`.
+    ///
+    /// This method differs from [`Cookie::value()`] in that it returns a
+    /// string with the same lifetime as the originally parsed string. This
+    /// lifetime may outlive `self`. If a longer lifetime is not required, or
+    /// you're unsure if you need a longer lifetime, use [`Cookie::value()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let cookie_string = format!("{}={}", "foo", "bar");
+    ///
+    /// // `c` will be dropped at the end of the scope, but `value` will live on
+    /// let value = {
+    ///     let c = Cookie::parse(cookie_string.as_str()).unwrap();
+    ///     c.value_raw()
+    /// };
+    ///
+    /// assert_eq!(value, Some("bar"));
+    /// ```
+    #[inline]
+    pub fn value_raw(&self) -> Option<&'c str> {
+        self.cookie_string.as_ref()
+            .and_then(|s| self.value.to_raw_str(s))
+    }
+
+    /// Returns the `Path` of `self` as a string slice of the raw string `self`
+    /// was originally parsed from. If `self` was not originally parsed from a
+    /// raw string, or if `self` doesn't contain a `Path`, or if the `Path` has
+    /// changed since parsing, returns `None`.
+    ///
+    /// This method differs from [`Cookie::path()`] in that it returns a
+    /// string with the same lifetime as the originally parsed string. This
+    /// lifetime may outlive `self`. If a longer lifetime is not required, or
+    /// you're unsure if you need a longer lifetime, use [`Cookie::path()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let cookie_string = format!("{}={}; Path=/", "foo", "bar");
+    ///
+    /// // `c` will be dropped at the end of the scope, but `path` will live on
+    /// let path = {
+    ///     let c = Cookie::parse(cookie_string.as_str()).unwrap();
+    ///     c.path_raw()
+    /// };
+    ///
+    /// assert_eq!(path, Some("/"));
+    /// ```
+    #[inline]
+    pub fn path_raw(&self) -> Option<&'c str> {
+        match (self.path.as_ref(), self.cookie_string.as_ref()) {
+            (Some(path), Some(string)) => path.to_raw_str(string),
+            _ => None,
+        }
+    }
+
+    /// Returns the `Domain` of `self` as a string slice of the raw string
+    /// `self` was originally parsed from. If `self` was not originally parsed
+    /// from a raw string, or if `self` doesn't contain a `Domain`, or if the
+    /// `Domain` has changed since parsing, returns `None`.
+    ///
+    /// This method differs from [`Cookie::domain()`] in that it returns a
+    /// string with the same lifetime as the originally parsed string. This
+    /// lifetime may outlive `self` struct. If a longer lifetime is not
+    /// required, or you're unsure if you need a longer lifetime, use
+    /// [`Cookie::domain()`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cookie::Cookie;
+    ///
+    /// let cookie_string = format!("{}={}; Domain=crates.io", "foo", "bar");
+    ///
+    /// //`c` will be dropped at the end of the scope, but `domain` will live on
+    /// let domain = {
+    ///     let c = Cookie::parse(cookie_string.as_str()).unwrap();
+    ///     c.domain_raw()
+    /// };
+    ///
+    /// assert_eq!(domain, Some("crates.io"));
+    /// ```
+    #[inline]
+    pub fn domain_raw(&self) -> Option<&'c str> {
+        match (self.domain.as_ref(), self.cookie_string.as_ref()) {
+            (Some(domain), Some(string)) => domain.to_raw_str(string),
+            _ => None,
+        }
+    }
+
+    /// Wraps `self` in an encoded [`Display`]: a cost-free wrapper around
+    /// `Cookie` whose [`fmt::Display`] implementation percent-encodes the name
+    /// and value of the wrapped `Cookie`.
+    ///
+    /// The returned structure can be chained with [`Display::stripped()`] to
+    /// display only the name and value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::build("my name", "this; value?").secure(true).finish();
+    /// assert_eq!(&c.encoded().to_string(), "my%20name=this%3B%20value%3F; Secure");
+    /// assert_eq!(&c.encoded().stripped().to_string(), "my%20name=this%3B%20value%3F");
+    /// ```
+    #[cfg(feature = "percent-encode")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "percent-encode")))]
+    #[inline(always)]
+    pub fn encoded<'a>(&'a self) -> Display<'a, 'c> {
+        Display::new_encoded(self)
+    }
+
+    /// Wraps `self` in a stripped `Display`]: a cost-free wrapper around
+    /// `Cookie` whose [`fmt::Display`] implementation prints only the `name`
+    /// and `value` of the wrapped `Cookie`.
+    ///
+    /// The returned structure can be chained with [`Display::encoded()`] to
+    /// encode the name and value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let mut c = Cookie::build("key?", "value").secure(true).path("/").finish();
+    /// assert_eq!(&c.stripped().to_string(), "key?=value");
+    #[cfg_attr(feature = "percent-encode", doc = r##"
+// Note: `encoded()` is only available when `percent-encode` is enabled.
+assert_eq!(&c.stripped().encoded().to_string(), "key%3F=value");
+    #"##)]
+    /// ```
+    #[inline(always)]
+    pub fn stripped<'a>(&'a self) -> Display<'a, 'c> {
+        Display::new_stripped(self)
+    }
+}
+
+#[cfg(feature = "percent-encode")]
+mod encoding {
+    use percent_encoding::{AsciiSet, CONTROLS};
+
+    /// https://url.spec.whatwg.org/#fragment-percent-encode-set
+    const FRAGMENT: &AsciiSet = &CONTROLS
+        .add(b' ')
+        .add(b'"')
+        .add(b'<')
+        .add(b'>')
+        .add(b'`');
+
+    /// https://url.spec.whatwg.org/#path-percent-encode-set
+    const PATH: &AsciiSet = &FRAGMENT
+        .add(b'#')
+        .add(b'?')
+        .add(b'{')
+        .add(b'}');
+
+    /// https://url.spec.whatwg.org/#userinfo-percent-encode-set
+    const USERINFO: &AsciiSet = &PATH
+        .add(b'/')
+        .add(b':')
+        .add(b';')
+        .add(b'=')
+        .add(b'@')
+        .add(b'[')
+        .add(b'\\')
+        .add(b']')
+        .add(b'^')
+        .add(b'|')
+        .add(b'%');
+
+    /// https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1 + '(', ')'
+    const COOKIE: &AsciiSet = &USERINFO
+        .add(b'(')
+        .add(b')')
+        .add(b',');
+
+    /// Percent-encode a cookie name or value with the proper encoding set.
+    pub fn encode(string: &str) -> impl std::fmt::Display + '_ {
+        percent_encoding::percent_encode(string.as_bytes(), COOKIE)
+    }
+}
+
+/// Wrapper around `Cookie` whose `Display` implementation either
+/// percent-encodes the cookie's name and value, skips displaying the cookie's
+/// parameters (only displaying it's name and value), or both.
+///
+/// A value of this type can be obtained via [`Cookie::encoded()`] and
+/// [`Cookie::stripped()`], or an arbitrary chaining of the two methods. This
+/// type should only be used for its `Display` implementation.
+///
+/// # Example
+///
+/// ```rust
+/// use cookie::Cookie;
+///
+/// let c = Cookie::build("my name", "this; value%?").secure(true).finish();
+/// assert_eq!(&c.stripped().to_string(), "my name=this; value%?");
+#[cfg_attr(feature = "percent-encode", doc = r##"
+// Note: `encoded()` is only available when `percent-encode` is enabled.
+assert_eq!(&c.encoded().to_string(), "my%20name=this%3B%20value%25%3F; Secure");
+assert_eq!(&c.stripped().encoded().to_string(), "my%20name=this%3B%20value%25%3F");
+assert_eq!(&c.encoded().stripped().to_string(), "my%20name=this%3B%20value%25%3F");
+"##)]
+/// ```
+pub struct Display<'a, 'c: 'a> {
+    cookie: &'a Cookie<'c>,
+    #[cfg(feature = "percent-encode")]
+    encode: bool,
+    strip: bool,
+}
+
+impl<'a, 'c: 'a> fmt::Display for Display<'a, 'c> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        #[cfg(feature = "percent-encode")] {
+            if self.encode {
+                let name = encoding::encode(self.cookie.name());
+                let value = encoding::encode(self.cookie.value());
+                write!(f, "{}={}", name, value)?;
+            } else {
+                write!(f, "{}={}", self.cookie.name(), self.cookie.value())?;
+            }
+        }
+
+        #[cfg(not(feature = "percent-encode"))] {
+            write!(f, "{}={}", self.cookie.name(), self.cookie.value())?;
+        }
+
+        match self.strip {
+            true => Ok(()),
+            false => self.cookie.fmt_parameters(f)
+        }
+    }
+}
+
+impl<'a, 'c> Display<'a, 'c> {
+    #[cfg(feature = "percent-encode")]
+    fn new_encoded(cookie: &'a Cookie<'c>) -> Self {
+        Display { cookie, strip: false, encode: true }
+    }
+
+    fn new_stripped(cookie: &'a Cookie<'c>) -> Self {
+        Display { cookie, strip: true, #[cfg(feature = "percent-encode")] encode: false }
+    }
+
+    /// Percent-encode the name and value pair.
+    #[inline]
+    #[cfg(feature = "percent-encode")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "percent-encode")))]
+    pub fn encoded(mut self) -> Self {
+        self.encode = true;
+        self
+    }
+
+    /// Only display the name and value.
+    #[inline]
+    pub fn stripped(mut self) -> Self {
+        self.strip = true;
+        self
+    }
+}
+
+impl<'c> fmt::Display for Cookie<'c> {
+    /// Formats the cookie `self` as a `Set-Cookie` header value.
+    ///
+    /// Does _not_ percent-encode any values. To percent-encode, use
+    /// [`Cookie::encoded()`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Cookie;
+    ///
+    /// let mut cookie = Cookie::build("foo", "bar")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(&cookie.to_string(), "foo=bar; Path=/");
+    /// ```
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}={}", self.name(), self.value())?;
+        self.fmt_parameters(f)
+    }
+}
+
+impl FromStr for Cookie<'static> {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Cookie<'static>, ParseError> {
+        Cookie::parse(s).map(|c| c.into_owned())
+    }
+}
+
+impl<'a, 'b> PartialEq<Cookie<'b>> for Cookie<'a> {
+    fn eq(&self, other: &Cookie<'b>) -> bool {
+        let so_far_so_good = self.name() == other.name()
+            && self.value() == other.value()
+            && self.http_only() == other.http_only()
+            && self.secure() == other.secure()
+            && self.max_age() == other.max_age()
+            && self.expires() == other.expires();
+
+        if !so_far_so_good {
+            return false;
+        }
+
+        match (self.path(), other.path()) {
+            (Some(a), Some(b)) if a.eq_ignore_ascii_case(b) => {}
+            (None, None) => {}
+            _ => return false,
+        };
+
+        match (self.domain(), other.domain()) {
+            (Some(a), Some(b)) if a.eq_ignore_ascii_case(b) => {}
+            (None, None) => {}
+            _ => return false,
+        };
+
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{Cookie, SameSite, parse::parse_date};
+    use time::{Duration, OffsetDateTime};
+
+    #[test]
+    fn format() {
+        let cookie = Cookie::new("foo", "bar");
+        assert_eq!(&cookie.to_string(), "foo=bar");
+
+        let cookie = Cookie::build("foo", "bar")
+            .http_only(true).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; HttpOnly");
+
+        let cookie = Cookie::build("foo", "bar")
+            .max_age(Duration::seconds(10)).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; Max-Age=10");
+
+        let cookie = Cookie::build("foo", "bar")
+            .secure(true).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; Secure");
+
+        let cookie = Cookie::build("foo", "bar")
+            .path("/").finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; Path=/");
+
+        let cookie = Cookie::build("foo", "bar")
+            .domain("www.rust-lang.org").finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; Domain=www.rust-lang.org");
+
+        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
+        let expires = parse_date(time_str, &crate::parse::FMT1).unwrap();
+        let cookie = Cookie::build("foo", "bar")
+            .expires(expires).finish();
+        assert_eq!(&cookie.to_string(),
+                   "foo=bar; Expires=Wed, 21 Oct 2015 07:28:00 GMT");
+
+        let cookie = Cookie::build("foo", "bar")
+            .same_site(SameSite::Strict).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; SameSite=Strict");
+
+        let cookie = Cookie::build("foo", "bar")
+            .same_site(SameSite::Lax).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; SameSite=Lax");
+
+        let mut cookie = Cookie::build("foo", "bar")
+            .same_site(SameSite::None).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; SameSite=None; Secure");
+
+        cookie.set_same_site(None);
+        assert_eq!(&cookie.to_string(), "foo=bar");
+
+        let mut cookie = Cookie::build("foo", "bar")
+            .same_site(SameSite::None)
+            .secure(false)
+            .finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; SameSite=None");
+        cookie.set_secure(true);
+        assert_eq!(&cookie.to_string(), "foo=bar; SameSite=None; Secure");
+    }
+
+    #[test]
+    #[ignore]
+    fn format_date_wraps() {
+        let expires = OffsetDateTime::UNIX_EPOCH + Duration::MAX;
+        let cookie = Cookie::build("foo", "bar").expires(expires).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; Expires=Fri, 31 Dec 9999 23:59:59 GMT");
+
+        let expires = time::macros::datetime!(9999-01-01 0:00 UTC) + Duration::days(1000);
+        let cookie = Cookie::build("foo", "bar").expires(expires).finish();
+        assert_eq!(&cookie.to_string(), "foo=bar; Expires=Fri, 31 Dec 9999 23:59:59 GMT");
+    }
+
+    #[test]
+    fn cookie_string_long_lifetimes() {
+        let cookie_string = "bar=baz; Path=/subdir; HttpOnly; Domain=crates.io".to_owned();
+        let (name, value, path, domain) = {
+            // Create a cookie passing a slice
+            let c = Cookie::parse(cookie_string.as_str()).unwrap();
+            (c.name_raw(), c.value_raw(), c.path_raw(), c.domain_raw())
+        };
+
+        assert_eq!(name, Some("bar"));
+        assert_eq!(value, Some("baz"));
+        assert_eq!(path, Some("/subdir"));
+        assert_eq!(domain, Some("crates.io"));
+    }
+
+    #[test]
+    fn owned_cookie_string() {
+        let cookie_string = "bar=baz; Path=/subdir; HttpOnly; Domain=crates.io".to_owned();
+        let (name, value, path, domain) = {
+            // Create a cookie passing an owned string
+            let c = Cookie::parse(cookie_string).unwrap();
+            (c.name_raw(), c.value_raw(), c.path_raw(), c.domain_raw())
+        };
+
+        assert_eq!(name, None);
+        assert_eq!(value, None);
+        assert_eq!(path, None);
+        assert_eq!(domain, None);
+    }
+
+    #[test]
+    fn owned_cookie_struct() {
+        let cookie_string = "bar=baz; Path=/subdir; HttpOnly; Domain=crates.io";
+        let (name, value, path, domain) = {
+            // Create an owned cookie
+            let c = Cookie::parse(cookie_string).unwrap().into_owned();
+
+            (c.name_raw(), c.value_raw(), c.path_raw(), c.domain_raw())
+        };
+
+        assert_eq!(name, None);
+        assert_eq!(value, None);
+        assert_eq!(path, None);
+        assert_eq!(domain, None);
+    }
+
+    #[test]
+    #[cfg(feature = "percent-encode")]
+    fn format_encoded() {
+        let cookie = Cookie::build("foo !%?=", "bar;;, a").finish();
+        let cookie_str = cookie.encoded().to_string();
+        assert_eq!(&cookie_str, "foo%20!%25%3F%3D=bar%3B%3B%2C%20a");
+
+        let cookie = Cookie::parse_encoded(cookie_str).unwrap();
+        assert_eq!(cookie.name_value(), ("foo !%?=", "bar;;, a"));
+    }
+}
diff --git a/third_party/rust/cookie/src/parse.rs b/third_party/rust/cookie/src/parse.rs
new file mode 100644
index 0000000000..dcd15b7b32
--- /dev/null
+++ b/third_party/rust/cookie/src/parse.rs
@@ -0,0 +1,550 @@
+use std::borrow::Cow;
+use std::error::Error;
+use std::convert::{From, TryFrom};
+use std::str::Utf8Error;
+use std::fmt;
+
+#[allow(unused_imports, deprecated)]
+use std::ascii::AsciiExt;
+
+#[cfg(feature = "percent-encode")]
+use percent_encoding::percent_decode;
+use time::{PrimitiveDateTime, Duration, OffsetDateTime};
+use time::{parsing::Parsable, macros::format_description, format_description::FormatItem};
+
+use crate::{Cookie, SameSite, CookieStr};
+
+// The three formats spec'd in http://tools.ietf.org/html/rfc2616#section-3.3.1.
+// Additional ones as encountered in the real world.
+pub static FMT1: &[FormatItem<'_>] = format_description!("[weekday repr:short], [day] [month repr:short] [year padding:none] [hour]:[minute]:[second] GMT");
+pub static FMT2: &[FormatItem<'_>] = format_description!("[weekday], [day]-[month repr:short]-[year repr:last_two] [hour]:[minute]:[second] GMT");
+pub static FMT3: &[FormatItem<'_>] = format_description!("[weekday repr:short] [month repr:short] [day padding:space] [hour]:[minute]:[second] [year padding:none]");
+pub static FMT4: &[FormatItem<'_>] = format_description!("[weekday repr:short], [day]-[month repr:short]-[year padding:none] [hour]:[minute]:[second] GMT");
+
+/// Enum corresponding to a parsing error.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[non_exhaustive]
+pub enum ParseError {
+    /// The cookie did not contain a name/value pair.
+    MissingPair,
+    /// The cookie's name was empty.
+    EmptyName,
+    /// Decoding the cookie's name or value resulted in invalid UTF-8.
+    Utf8Error(Utf8Error),
+}
+
+impl ParseError {
+    /// Returns a description of this error as a string
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            ParseError::MissingPair => "the cookie is missing a name/value pair",
+            ParseError::EmptyName => "the cookie's name is empty",
+            ParseError::Utf8Error(_) => {
+                "decoding the cookie's name or value resulted in invalid UTF-8"
+            }
+        }
+    }
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<Utf8Error> for ParseError {
+    fn from(error: Utf8Error) -> ParseError {
+        ParseError::Utf8Error(error)
+    }
+}
+
+impl Error for ParseError {
+    fn description(&self) -> &str {
+        self.as_str()
+    }
+}
+
+fn indexes_of(needle: &str, haystack: &str) -> Option<(usize, usize)> {
+    let haystack_start = haystack.as_ptr() as usize;
+    let needle_start = needle.as_ptr() as usize;
+
+    if needle_start < haystack_start {
+        return None;
+    }
+
+    if (needle_start + needle.len()) > (haystack_start + haystack.len()) {
+        return None;
+    }
+
+    let start = needle_start - haystack_start;
+    let end = start + needle.len();
+    Some((start, end))
+}
+
+#[cfg(feature = "percent-encode")]
+fn name_val_decoded(
+    name: &str,
+    val: &str
+) -> Result<Option<(CookieStr<'static>, CookieStr<'static>)>, ParseError> {
+    let decoded_name = percent_decode(name.as_bytes()).decode_utf8()?;
+    let decoded_value = percent_decode(val.as_bytes()).decode_utf8()?;
+
+    if let (&Cow::Borrowed(_), &Cow::Borrowed(_)) = (&decoded_name, &decoded_value) {
+         Ok(None)
+    } else {
+        let name = CookieStr::Concrete(Cow::Owned(decoded_name.into()));
+        let val = CookieStr::Concrete(Cow::Owned(decoded_value.into()));
+        Ok(Some((name, val)))
+    }
+}
+
+#[cfg(not(feature = "percent-encode"))]
+fn name_val_decoded(
+    _: &str,
+    _: &str
+) -> Result<Option<(CookieStr<'static>, CookieStr<'static>)>, ParseError> {
+    unreachable!("This function should never be called with 'percent-encode' disabled!")
+}
+
+fn trim_quotes(s: &str) -> &str {
+    if s.len() < 2 {
+        return s;
+    }
+
+    match (s.chars().next(), s.chars().last()) {
+        (Some('"'), Some('"')) => &s[1..(s.len() - 1)],
+        _ => s
+    }
+}
+
+// This function does the real parsing but _does not_ set the `cookie_string` in
+// the returned cookie object. This only exists so that the borrow to `s` is
+// returned at the end of the call, allowing the `cookie_string` field to be
+// set in the outer `parse` function.
+fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
+    let mut attributes = s.split(';');
+
+    // Determine the name = val.
+    let key_value = attributes.next().expect("first str::split().next() returns Some");
+    let (name, value) = match key_value.find('=') {
+        Some(i) => {
+            let (key, value) = (key_value[..i].trim(), key_value[(i + 1)..].trim());
+            (key, trim_quotes(value).trim())
+        },
+        None => return Err(ParseError::MissingPair)
+    };
+
+    if name.is_empty() {
+        return Err(ParseError::EmptyName);
+    }
+
+    // If there is nothing to decode, or we're not decoding, use indexes.
+    let indexed_names = |s, name, value| {
+        let name_indexes = indexes_of(name, s).expect("name sub");
+        let value_indexes = indexes_of(value, s).expect("value sub");
+        let name = CookieStr::Indexed(name_indexes.0, name_indexes.1);
+        let value = CookieStr::Indexed(value_indexes.0, value_indexes.1);
+        (name, value)
+    };
+
+    // Create a cookie with all of the defaults. We'll fill things in while we
+    // iterate through the parameters below.
+    let (name, value) = if decode {
+        match name_val_decoded(name, value)? {
+            Some((name, value)) => (name, value),
+            None => indexed_names(s, name, value)
+        }
+    } else {
+        indexed_names(s, name, value)
+    };
+
+    let mut cookie: Cookie<'c> = Cookie {
+        name, value,
+        cookie_string: None,
+        expires: None,
+        max_age: None,
+        domain: None,
+        path: None,
+        secure: None,
+        http_only: None,
+        same_site: None
+    };
+
+    for attr in attributes {
+        let (key, value) = match attr.find('=') {
+            Some(i) => (attr[..i].trim(), Some(attr[(i + 1)..].trim())),
+            None => (attr.trim(), None),
+        };
+
+        match (&*key.to_ascii_lowercase(), value) {
+            ("secure", _) => cookie.secure = Some(true),
+            ("httponly", _) => cookie.http_only = Some(true),
+            ("max-age", Some(mut v)) => cookie.max_age = {
+                let is_negative = v.starts_with('-');
+                if is_negative {
+                    v = &v[1..];
+                }
+
+                if !v.chars().all(|d| d.is_digit(10)) {
+                    continue
+                }
+
+                // From RFC 6265 5.2.2: neg values indicate that the earliest
+                // expiration should be used, so set the max age to 0 seconds.
+                if is_negative {
+                    Some(Duration::ZERO)
+                } else {
+                    Some(v.parse::<i64>()
+                        .map(Duration::seconds)
+                        .unwrap_or_else(|_| Duration::seconds(i64::max_value())))
+                }
+            },
+            ("domain", Some(mut domain)) if !domain.is_empty() => {
+                if domain.starts_with('.') {
+                    domain = &domain[1..];
+                }
+
+                let (i, j) = indexes_of(domain, s).expect("domain sub");
+                cookie.domain = Some(CookieStr::Indexed(i, j));
+            }
+            ("path", Some(v)) => {
+                let (i, j) = indexes_of(v, s).expect("path sub");
+                cookie.path = Some(CookieStr::Indexed(i, j));
+            }
+            ("samesite", Some(v)) => {
+                if v.eq_ignore_ascii_case("strict") {
+                    cookie.same_site = Some(SameSite::Strict);
+                } else if v.eq_ignore_ascii_case("lax") {
+                    cookie.same_site = Some(SameSite::Lax);
+                } else if v.eq_ignore_ascii_case("none") {
+                    cookie.same_site = Some(SameSite::None);
+                } else {
+                    // We do nothing here, for now. When/if the `SameSite`
+                    // attribute becomes standard, the spec says that we should
+                    // ignore this cookie, i.e, fail to parse it, when an
+                    // invalid value is passed in. The draft is at
+                    // http://httpwg.org/http-extensions/draft-ietf-httpbis-cookie-same-site.html.
+                }
+            }
+            ("expires", Some(v)) => {
+                let tm = parse_date(v, &FMT1)
+                    .or_else(|_| parse_date(v, &FMT2))
+                    .or_else(|_| parse_date(v, &FMT3))
+                    .or_else(|_| parse_date(v, &FMT4));
+                    // .or_else(|_| parse_date(v, &FMT5));
+
+                if let Ok(time) = tm {
+                    cookie.expires = Some(time.into())
+                }
+            }
+            _ => {
+                // We're going to be permissive here. If we have no idea what
+                // this is, then it's something nonstandard. We're not going to
+                // store it (because it's not compliant), but we're also not
+                // going to emit an error.
+            }
+        }
+    }
+
+    Ok(cookie)
+}
+
+pub(crate) fn parse_cookie<'c, S>(cow: S, decode: bool) -> Result<Cookie<'c>, ParseError>
+    where S: Into<Cow<'c, str>>
+{
+    let s = cow.into();
+    let mut cookie = parse_inner(&s, decode)?;
+    cookie.cookie_string = Some(s);
+    Ok(cookie)
+}
+
+pub(crate) fn parse_date(s: &str, format: &impl Parsable) -> Result<OffsetDateTime, time::Error> {
+    // Parse. Handle "abbreviated" dates like Chromium. See cookie#162.
+    let mut date = format.parse(s.as_bytes())?;
+    if let Some(y) = date.year().or_else(|| date.year_last_two().map(|v| v as i32)) {
+        let offset = match y {
+            0..=68 => 2000,
+            69..=99 => 1900,
+            _ => 0,
+        };
+
+        date.set_year(y + offset);
+    }
+
+    Ok(PrimitiveDateTime::try_from(date)?.assume_utc())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_date;
+    use crate::{Cookie, SameSite};
+    use time::Duration;
+
+    macro_rules! assert_eq_parse {
+        ($string:expr, $expected:expr) => (
+            let cookie = match Cookie::parse($string) {
+                Ok(cookie) => cookie,
+                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e)
+            };
+
+            assert_eq!(cookie, $expected);
+        )
+    }
+
+    macro_rules! assert_ne_parse {
+        ($string:expr, $expected:expr) => (
+            let cookie = match Cookie::parse($string) {
+                Ok(cookie) => cookie,
+                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e)
+            };
+
+            assert_ne!(cookie, $expected);
+        )
+    }
+
+    #[test]
+    fn parse_same_site() {
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::Lax)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=Lax", expected);
+        assert_eq_parse!("foo=bar; SameSite=lax", expected);
+        assert_eq_parse!("foo=bar; SameSite=LAX", expected);
+        assert_eq_parse!("foo=bar; samesite=Lax", expected);
+        assert_eq_parse!("foo=bar; SAMESITE=Lax", expected);
+
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::Strict)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=Strict", expected);
+        assert_eq_parse!("foo=bar; SameSITE=Strict", expected);
+        assert_eq_parse!("foo=bar; SameSite=strict", expected);
+        assert_eq_parse!("foo=bar; SameSite=STrICT", expected);
+        assert_eq_parse!("foo=bar; SameSite=STRICT", expected);
+
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::None)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=None", expected);
+        assert_eq_parse!("foo=bar; SameSITE=none", expected);
+        assert_eq_parse!("foo=bar; SameSite=NOne", expected);
+        assert_eq_parse!("foo=bar; SameSite=nOne", expected);
+    }
+
+    #[test]
+    fn parse() {
+        assert!(Cookie::parse("bar").is_err());
+        assert!(Cookie::parse("=bar").is_err());
+        assert!(Cookie::parse(" =bar").is_err());
+        assert!(Cookie::parse("foo=").is_ok());
+
+        let expected = Cookie::build("foo", "bar=baz").finish();
+        assert_eq_parse!("foo=bar=baz", expected);
+
+        let expected = Cookie::build("foo", "\"bar\"").finish();
+        assert_eq_parse!("foo=\"\"bar\"\"", expected);
+
+        let expected = Cookie::build("foo", "\"bar").finish();
+        assert_eq_parse!("foo=  \"bar", expected);
+        assert_eq_parse!("foo=\"bar  ", expected);
+        assert_eq_parse!("foo=\"\"bar\"", expected);
+        assert_eq_parse!("foo=\"\"bar  \"", expected);
+        assert_eq_parse!("foo=\"\"bar  \"  ", expected);
+
+        let expected = Cookie::build("foo", "bar\"").finish();
+        assert_eq_parse!("foo=bar\"", expected);
+        assert_eq_parse!("foo=\"bar\"\"", expected);
+        assert_eq_parse!("foo=\"  bar\"\"", expected);
+        assert_eq_parse!("foo=\"  bar\"  \"  ", expected);
+
+        let mut expected = Cookie::build("foo", "bar").finish();
+        assert_eq_parse!("foo=bar", expected);
+        assert_eq_parse!("foo = bar", expected);
+        assert_eq_parse!("foo=\"bar\"", expected);
+        assert_eq_parse!(" foo=bar ", expected);
+        assert_eq_parse!(" foo=\"bar   \" ", expected);
+        assert_eq_parse!(" foo=bar ;Domain=", expected);
+        assert_eq_parse!(" foo=bar ;Domain= ", expected);
+        assert_eq_parse!(" foo=bar ;Ignored", expected);
+
+        let mut unexpected = Cookie::build("foo", "bar").http_only(false).finish();
+        assert_ne_parse!(" foo=bar ;HttpOnly", unexpected);
+        assert_ne_parse!(" foo=bar; httponly", unexpected);
+
+        expected.set_http_only(true);
+        assert_eq_parse!(" foo=bar ;HttpOnly", expected);
+        assert_eq_parse!(" foo=bar ;httponly", expected);
+        assert_eq_parse!(" foo=bar ;HTTPONLY=whatever", expected);
+        assert_eq_parse!(" foo=bar ; sekure; HTTPONLY", expected);
+
+        expected.set_secure(true);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure=aaaa", expected);
+
+        unexpected.set_http_only(true);
+        unexpected.set_secure(true);
+        assert_ne_parse!(" foo=bar ;HttpOnly; skeure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; =secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly;", unexpected);
+
+        unexpected.set_secure(false);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+
+        expected.set_max_age(Duration::ZERO);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=0", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0 ", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=-1", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", expected);
+
+        expected.set_max_age(Duration::minutes(1));
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=60", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age =   60 ", expected);
+
+        expected.set_max_age(Duration::seconds(4));
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 4 ", expected);
+
+        unexpected.set_secure(true);
+        unexpected.set_max_age(Duration::minutes(1));
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=122", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 38 ", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=51", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0", unexpected);
+
+        expected.set_path("/");
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/", expected);
+
+        expected.set_path("/foo");
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path = /foo", expected);
+
+        unexpected.set_max_age(Duration::seconds(4));
+        unexpected.set_path("/bar");
+        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", unexpected);
+        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/baz", unexpected);
+
+        expected.set_domain("www.foo.com");
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=www.foo.com", expected);
+
+        expected.set_domain("foo.com");
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=foo.com", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=FOO.COM", expected);
+
+        unexpected.set_path("/foo");
+        unexpected.set_domain("bar.com");
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=foo.com", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=FOO.COM", unexpected);
+
+        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
+        let expires = parse_date(time_str, &super::FMT1).unwrap();
+        expected.set_expires(expires);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT", expected);
+
+        unexpected.set_domain("foo.com");
+        let bad_expires = parse_date(time_str, &super::FMT1).unwrap();
+        expected.set_expires(bad_expires);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+            Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT", unexpected);
+    }
+
+    #[test]
+    fn parse_abbreviated_years() {
+        let cookie_str = "foo=bar; expires=Thu, 10-Sep-20 20:00:00 GMT";
+        let cookie = Cookie::parse(cookie_str).unwrap();
+        assert_eq!(cookie.expires_datetime().unwrap().year(), 2020);
+
+        let cookie_str = "foo=bar; expires=Thu, 10-Sep-68 20:00:00 GMT";
+        let cookie = Cookie::parse(cookie_str).unwrap();
+        assert_eq!(cookie.expires_datetime().unwrap().year(), 2068);
+
+        let cookie_str = "foo=bar; expires=Thu, 10-Sep-69 20:00:00 GMT";
+        let cookie = Cookie::parse(cookie_str).unwrap();
+        assert_eq!(cookie.expires_datetime().unwrap().year(), 1969);
+
+        let cookie_str = "foo=bar; expires=Thu, 10-Sep-99 20:00:00 GMT";
+        let cookie = Cookie::parse(cookie_str).unwrap();
+        assert_eq!(cookie.expires_datetime().unwrap().year(), 1999);
+
+        let cookie_str = "foo=bar; expires=Thu, 10-Sep-2069 20:00:00 GMT";
+        let cookie = Cookie::parse(cookie_str).unwrap();
+        assert_eq!(cookie.expires_datetime().unwrap().year(), 2069);
+    }
+
+    #[test]
+    fn parse_variant_date_fmts() {
+        let cookie_str = "foo=bar; expires=Sun, 06 Nov 1994 08:49:37 GMT";
+        Cookie::parse(cookie_str).unwrap().expires_datetime().unwrap();
+
+        let cookie_str = "foo=bar; expires=Sunday, 06-Nov-94 08:49:37 GMT";
+        Cookie::parse(cookie_str).unwrap().expires_datetime().unwrap();
+
+        let cookie_str = "foo=bar; expires=Sun Nov  6 08:49:37 1994";
+        Cookie::parse(cookie_str).unwrap().expires_datetime().unwrap();
+    }
+
+    #[test]
+    fn parse_very_large_max_ages() {
+        let mut expected = Cookie::build("foo", "bar")
+            .max_age(Duration::seconds(i64::max_value()))
+            .finish();
+
+        let string = format!("foo=bar; Max-Age={}", 1u128 << 100);
+        assert_eq_parse!(&string, expected);
+
+        expected.set_max_age(Duration::seconds(0));
+        assert_eq_parse!("foo=bar; Max-Age=-129", expected);
+
+        let string = format!("foo=bar; Max-Age=-{}", 1u128 << 100);
+        assert_eq_parse!(&string, expected);
+
+        let string = format!("foo=bar; Max-Age=-{}", i64::max_value());
+        assert_eq_parse!(&string, expected);
+
+        let string = format!("foo=bar; Max-Age={}", i64::max_value());
+        expected.set_max_age(Duration::seconds(i64::max_value()));
+        assert_eq_parse!(&string, expected);
+    }
+
+    #[test]
+    fn odd_characters() {
+        let expected = Cookie::new("foo", "b%2Fr");
+        assert_eq_parse!("foo=b%2Fr", expected);
+    }
+
+    #[test]
+    #[cfg(feature = "percent-encode")]
+    fn odd_characters_encoded() {
+        let expected = Cookie::new("foo", "b/r");
+        let cookie = match Cookie::parse_encoded("foo=b%2Fr") {
+            Ok(cookie) => cookie,
+            Err(e) => panic!("Failed to parse: {:?}", e)
+        };
+
+        assert_eq!(cookie, expected);
+    }
+
+    #[test]
+    fn do_not_panic_on_large_max_ages() {
+        let max_seconds = Duration::MAX.whole_seconds();
+        let expected = Cookie::build("foo", "bar")
+            .max_age(Duration::seconds(max_seconds))
+            .finish();
+        let too_many_seconds = (max_seconds as u64) + 1;
+        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", too_many_seconds), expected);
+    }
+}
diff --git a/third_party/rust/cookie/src/secure/key.rs b/third_party/rust/cookie/src/secure/key.rs
new file mode 100644
index 0000000000..9c2228eb3a
--- /dev/null
+++ b/third_party/rust/cookie/src/secure/key.rs
@@ -0,0 +1,301 @@
+use std::convert::TryFrom;
+
+const SIGNING_KEY_LEN: usize = 32;
+const ENCRYPTION_KEY_LEN: usize = 32;
+const COMBINED_KEY_LENGTH: usize = SIGNING_KEY_LEN + ENCRYPTION_KEY_LEN;
+
+// Statically ensure the numbers above are in-sync.
+#[cfg(feature = "signed")]
+const_assert!(crate::secure::signed::KEY_LEN == SIGNING_KEY_LEN);
+#[cfg(feature = "private")]
+const_assert!(crate::secure::private::KEY_LEN == ENCRYPTION_KEY_LEN);
+
+/// A cryptographic master key for use with `Signed` and/or `Private` jars.
+///
+/// This structure encapsulates secure, cryptographic keys for use with both
+/// [`PrivateJar`](crate::PrivateJar) and [`SignedJar`](crate::SignedJar). A
+/// single instance of a `Key` can be used for both a `PrivateJar` and a
+/// `SignedJar` simultaneously with no notable security implications.
+#[cfg_attr(all(nightly, doc), doc(cfg(any(feature = "private", feature = "signed"))))]
+#[derive(Clone)]
+pub struct Key([u8; COMBINED_KEY_LENGTH /* SIGNING | ENCRYPTION */]);
+
+impl PartialEq for Key {
+    fn eq(&self, other: &Self) -> bool {
+        use subtle::ConstantTimeEq;
+
+        self.0.ct_eq(&other.0).into()
+    }
+}
+
+impl Key {
+    // An empty key structure, to be filled.
+    const fn zero() -> Self {
+        Key([0; COMBINED_KEY_LENGTH])
+    }
+
+    /// Creates a new `Key` from a 512-bit cryptographically random string.
+    ///
+    /// The supplied key must be at least 512-bits (64 bytes). For security, the
+    /// master key _must_ be cryptographically random.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `key` is less than 64 bytes in length.
+    ///
+    /// For a non-panicking version, use [`Key::try_from()`] or generate a key with
+    /// [`Key::generate()`] or [`Key::try_generate()`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// # /*
+    /// let key = { /* a cryptographically random key >= 64 bytes */ };
+    /// # */
+    /// # let key: &Vec<u8> = &(0..64).collect();
+    ///
+    /// let key = Key::from(key);
+    /// ```
+    #[inline]
+    pub fn from(key: &[u8]) -> Key {
+        Key::try_from(key).unwrap()
+    }
+
+    /// Derives new signing/encryption keys from a master key.
+    ///
+    /// The master key must be at least 256-bits (32 bytes). For security, the
+    /// master key _must_ be cryptographically random. The keys are derived
+    /// deterministically from the master key.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `key` is less than 32 bytes in length.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// # /*
+    /// let master_key = { /* a cryptographically random key >= 32 bytes */ };
+    /// # */
+    /// # let master_key: &Vec<u8> = &(0..32).collect();
+    ///
+    /// let key = Key::derive_from(master_key);
+    /// ```
+    #[cfg(feature = "key-expansion")]
+    #[cfg_attr(all(nightly, doc), doc(cfg(feature = "key-expansion")))]
+    pub fn derive_from(master_key: &[u8]) -> Self {
+        if master_key.len() < 32 {
+            panic!("bad master key length: expected >= 32 bytes, found {}", master_key.len());
+        }
+
+        // Expand the master key into two HKDF generated keys.
+        const KEYS_INFO: &[u8] = b"COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM";
+        let mut both_keys = [0; COMBINED_KEY_LENGTH];
+        let hk = hkdf::Hkdf::<sha2::Sha256>::from_prk(master_key).expect("key length prechecked");
+        hk.expand(KEYS_INFO, &mut both_keys).expect("expand into keys");
+        Key::from(&both_keys)
+    }
+
+    /// Generates signing/encryption keys from a secure, random source. Keys are
+    /// generated nondeterministically.
+    ///
+    /// # Panics
+    ///
+    /// Panics if randomness cannot be retrieved from the operating system. See
+    /// [`Key::try_generate()`] for a non-panicking version.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// ```
+    pub fn generate() -> Key {
+        Self::try_generate().expect("failed to generate `Key` from randomness")
+    }
+
+    /// Attempts to generate signing/encryption keys from a secure, random
+    /// source. Keys are generated nondeterministically. If randomness cannot be
+    /// retrieved from the underlying operating system, returns `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// let key = Key::try_generate();
+    /// ```
+    pub fn try_generate() -> Option<Key> {
+        use crate::secure::rand::RngCore;
+
+        let mut rng = crate::secure::rand::thread_rng();
+        let mut key = Key::zero();
+        rng.try_fill_bytes(&mut key.0).ok()?;
+        Some(key)
+    }
+
+    /// Returns the raw bytes of a key suitable for signing cookies. Guaranteed
+    /// to be at least 32 bytes.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let signing_key = key.signing();
+    /// ```
+    pub fn signing(&self) -> &[u8] {
+        &self.0[..SIGNING_KEY_LEN]
+    }
+
+    /// Returns the raw bytes of a key suitable for encrypting cookies.
+    /// Guaranteed to be at least 32 bytes.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let encryption_key = key.encryption();
+    /// ```
+    pub fn encryption(&self) -> &[u8] {
+        &self.0[SIGNING_KEY_LEN..]
+    }
+
+    /// Returns the raw bytes of the master key. Guaranteed to be at least 64
+    /// bytes.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let master_key = key.master();
+    /// ```
+    pub fn master(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// An error indicating an issue with generating or constructing a key.
+#[cfg_attr(all(nightly, doc), doc(cfg(any(feature = "private", feature = "signed"))))]
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum KeyError {
+    /// Too few bytes (`.0`) were provided to generate a key.
+    ///
+    /// See [`Key::from()`] for minimum requirements.
+    TooShort(usize),
+}
+
+impl std::error::Error for KeyError { }
+
+impl std::fmt::Display for KeyError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            KeyError::TooShort(n) => {
+                write!(f, "key material is too short: expected >= {} bytes, got {} bytes",
+                       COMBINED_KEY_LENGTH, n)
+            }
+        }
+    }
+}
+
+impl TryFrom<&[u8]> for Key {
+    type Error = KeyError;
+
+    /// A fallible version of [`Key::from()`].
+    ///
+    /// Succeeds when [`Key::from()`] succeds and returns an error where
+    /// [`Key::from()`] panics, namely, if `key` is too short.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use std::convert::TryFrom;
+    /// use cookie::Key;
+    ///
+    /// # /*
+    /// let key = { /* a cryptographically random key >= 64 bytes */ };
+    /// # */
+    /// # let key: &Vec<u8> = &(0..64).collect();
+    /// # let key: &[u8] = &key[..];
+    /// assert!(Key::try_from(key).is_ok());
+    ///
+    /// // A key that's far too short to use.
+    /// let key = &[1, 2, 3, 4][..];
+    /// assert!(Key::try_from(key).is_err());
+    /// ```
+    fn try_from(key: &[u8]) -> Result<Self, Self::Error> {
+        if key.len() < COMBINED_KEY_LENGTH {
+            Err(KeyError::TooShort(key.len()))
+        } else {
+            let mut output = Key::zero();
+            output.0.copy_from_slice(&key[..COMBINED_KEY_LENGTH]);
+            Ok(output)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Key;
+
+    #[test]
+    fn from_works() {
+        let key = Key::from(&(0..64).collect::<Vec<_>>());
+
+        let signing: Vec<u8> = (0..32).collect();
+        assert_eq!(key.signing(), &*signing);
+
+        let encryption: Vec<u8> = (32..64).collect();
+        assert_eq!(key.encryption(), &*encryption);
+    }
+
+    #[test]
+    fn try_from_works() {
+        use core::convert::TryInto;
+        let data = (0..64).collect::<Vec<_>>();
+        let key_res: Result<Key, _> = data[0..63].try_into();
+        assert!(key_res.is_err());
+
+        let key_res: Result<Key, _> = data.as_slice().try_into();
+        assert!(key_res.is_ok());
+    }
+
+    #[test]
+    #[cfg(feature = "key-expansion")]
+    fn deterministic_derive() {
+        let master_key: Vec<u8> = (0..32).collect();
+
+        let key_a = Key::derive_from(&master_key);
+        let key_b = Key::derive_from(&master_key);
+
+        assert_eq!(key_a.signing(), key_b.signing());
+        assert_eq!(key_a.encryption(), key_b.encryption());
+        assert_ne!(key_a.encryption(), key_a.signing());
+
+        let master_key_2: Vec<u8> = (32..64).collect();
+        let key_2 = Key::derive_from(&master_key_2);
+
+        assert_ne!(key_2.signing(), key_a.signing());
+        assert_ne!(key_2.encryption(), key_a.encryption());
+    }
+
+    #[test]
+    fn non_deterministic_generate() {
+        let key_a = Key::generate();
+        let key_b = Key::generate();
+
+        assert_ne!(key_a.signing(), key_b.signing());
+        assert_ne!(key_a.encryption(), key_b.encryption());
+    }
+}
diff --git a/third_party/rust/cookie/src/secure/macros.rs b/third_party/rust/cookie/src/secure/macros.rs
new file mode 100644
index 0000000000..dfbddcf928
--- /dev/null
+++ b/third_party/rust/cookie/src/secure/macros.rs
@@ -0,0 +1,49 @@
+#[cfg(test)]
+macro_rules! assert_simple_behaviour {
+    ($clear:expr, $secure:expr) => ({
+        assert_eq!($clear.iter().count(), 0);
+
+        $secure.add(Cookie::new("name", "val"));
+        assert_eq!($clear.iter().count(), 1);
+        assert_eq!($secure.get("name").unwrap().value(), "val");
+        assert_ne!($clear.get("name").unwrap().value(), "val");
+
+        $secure.add(Cookie::new("another", "two"));
+        assert_eq!($clear.iter().count(), 2);
+
+        $clear.remove(Cookie::named("another"));
+        assert_eq!($clear.iter().count(), 1);
+
+        $secure.remove(Cookie::named("name"));
+        assert_eq!($clear.iter().count(), 0);
+    })
+}
+
+#[cfg(test)]
+macro_rules! assert_secure_behaviour {
+    ($clear:expr, $secure:expr) => ({
+        $secure.add(Cookie::new("secure", "secure"));
+        assert!($clear.get("secure").unwrap().value() != "secure");
+        assert!($secure.get("secure").unwrap().value() == "secure");
+
+        let mut cookie = $clear.get("secure").unwrap().clone();
+        let new_val = format!("{}l", cookie.value());
+        cookie.set_value(new_val);
+        $clear.add(cookie);
+        assert!($secure.get("secure").is_none());
+
+        let mut cookie = $clear.get("secure").unwrap().clone();
+        cookie.set_value("foobar");
+        $clear.add(cookie);
+        assert!($secure.get("secure").is_none());
+    })
+}
+
+// This is courtesty of `static_assertions`. That library is Copyright (c) 2017
+// Nikolai Vazquez. See https://github.com/nvzqz/static-assertions-rs for more.
+macro_rules! const_assert {
+    ($x:expr $(,)?) => {
+        #[allow(unknown_lints, clippy::eq_op)]
+        const _: [(); 0 - !{ const ASSERT: bool = $x; ASSERT } as usize] = [];
+    };
+}
diff --git a/third_party/rust/cookie/src/secure/mod.rs b/third_party/rust/cookie/src/secure/mod.rs
new file mode 100644
index 0000000000..ca066888e7
--- /dev/null
+++ b/third_party/rust/cookie/src/secure/mod.rs
@@ -0,0 +1,14 @@
+extern crate rand;
+extern crate base64;
+
+#[macro_use]
+mod macros;
+mod key;
+
+pub use self::key::*;
+
+#[cfg(feature = "private")] mod private;
+#[cfg(feature = "private")] pub use self::private::*;
+
+#[cfg(feature = "signed")] mod signed;
+#[cfg(feature = "signed")] pub use self::signed::*;
diff --git a/third_party/rust/cookie/src/secure/private.rs b/third_party/rust/cookie/src/secure/private.rs
new file mode 100644
index 0000000000..1264c3983c
--- /dev/null
+++ b/third_party/rust/cookie/src/secure/private.rs
@@ -0,0 +1,264 @@
+extern crate aes_gcm;
+
+use std::convert::TryInto;
+use std::borrow::{Borrow, BorrowMut};
+
+use crate::secure::{base64, rand, Key};
+use crate::{Cookie, CookieJar};
+
+use self::aes_gcm::aead::{generic_array::GenericArray, Aead, AeadInPlace, KeyInit, Payload};
+use self::aes_gcm::Aes256Gcm;
+use self::rand::RngCore;
+
+// Keep these in sync, and keep the key len synced with the `private` docs as
+// well as the `KEYS_INFO` const in secure::Key.
+pub(crate) const NONCE_LEN: usize = 12;
+pub(crate) const TAG_LEN: usize = 16;
+pub(crate) const KEY_LEN: usize = 32;
+
+/// A child cookie jar that provides authenticated encryption for its cookies.
+///
+/// A _private_ child jar signs and encrypts all the cookies added to it and
+/// verifies and decrypts cookies retrieved from it. Any cookies stored in a
+/// `PrivateJar` are simultaneously assured confidentiality, integrity, and
+/// authenticity. In other words, clients cannot discover nor tamper with the
+/// contents of a cookie, nor can they fabricate cookie data.
+#[cfg_attr(all(nightly, doc), doc(cfg(feature = "private")))]
+pub struct PrivateJar<J> {
+    parent: J,
+    key: [u8; KEY_LEN]
+}
+
+impl<J> PrivateJar<J> {
+    /// Creates a new child `PrivateJar` with parent `parent` and key `key`.
+    /// This method is typically called indirectly via the `signed` method of
+    /// `CookieJar`.
+    pub(crate) fn new(parent: J, key: &Key) -> PrivateJar<J> {
+        PrivateJar { parent, key: key.encryption().try_into().expect("enc key len") }
+    }
+
+    /// Encrypts the cookie's value with authenticated encryption providing
+    /// confidentiality, integrity, and authenticity.
+    fn encrypt_cookie(&self, cookie: &mut Cookie) {
+        // Create a vec to hold the [nonce | cookie value | tag].
+        let cookie_val = cookie.value().as_bytes();
+        let mut data = vec![0; NONCE_LEN + cookie_val.len() + TAG_LEN];
+
+        // Split data into three: nonce, input/output, tag. Copy input.
+        let (nonce, in_out) = data.split_at_mut(NONCE_LEN);
+        let (in_out, tag) = in_out.split_at_mut(cookie_val.len());
+        in_out.copy_from_slice(cookie_val);
+
+        // Fill nonce piece with random data.
+        let mut rng = self::rand::thread_rng();
+        rng.try_fill_bytes(nonce).expect("couldn't random fill nonce");
+        let nonce = GenericArray::clone_from_slice(nonce);
+
+        // Perform the actual sealing operation, using the cookie's name as
+        // associated data to prevent value swapping.
+        let aad = cookie.name().as_bytes();
+        let aead = Aes256Gcm::new(GenericArray::from_slice(&self.key));
+        let aad_tag = aead.encrypt_in_place_detached(&nonce, aad, in_out)
+            .expect("encryption failure!");
+
+        // Copy the tag into the tag piece.
+        tag.copy_from_slice(&aad_tag);
+
+        // Base64 encode [nonce | encrypted value | tag].
+        cookie.set_value(base64::encode(&data));
+    }
+
+    /// Given a sealed value `str` and a key name `name`, where the nonce is
+    /// prepended to the original value and then both are Base64 encoded,
+    /// verifies and decrypts the sealed value and returns it. If there's a
+    /// problem, returns an `Err` with a string describing the issue.
+    fn unseal(&self, name: &str, value: &str) -> Result<String, &'static str> {
+        let data = base64::decode(value).map_err(|_| "bad base64 value")?;
+        if data.len() <= NONCE_LEN {
+            return Err("length of decoded data is <= NONCE_LEN");
+        }
+
+        let (nonce, cipher) = data.split_at(NONCE_LEN);
+        let payload = Payload { msg: cipher, aad: name.as_bytes() };
+
+        let aead = Aes256Gcm::new(GenericArray::from_slice(&self.key));
+        aead.decrypt(GenericArray::from_slice(nonce), payload)
+            .map_err(|_| "invalid key/nonce/value: bad seal")
+            .and_then(|s| String::from_utf8(s).map_err(|_| "bad unsealed utf8"))
+    }
+
+    /// Authenticates and decrypts `cookie`, returning the plaintext version if
+    /// decryption succeeds or `None` otherwise. Authenticatation and decryption
+    /// _always_ succeeds if `cookie` was generated by a `PrivateJar` with the
+    /// same key as `self`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// assert!(jar.private(&key).get("name").is_none());
+    ///
+    /// jar.private_mut(&key).add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.private(&key).get("name").unwrap().value(), "value");
+    ///
+    /// let plain = jar.get("name").cloned().unwrap();
+    /// assert_ne!(plain.value(), "value");
+    /// let decrypted = jar.private(&key).decrypt(plain).unwrap();
+    /// assert_eq!(decrypted.value(), "value");
+    ///
+    /// let plain = Cookie::new("plaintext", "hello");
+    /// assert!(jar.private(&key).decrypt(plain).is_none());
+    /// ```
+    pub fn decrypt(&self, mut cookie: Cookie<'static>) -> Option<Cookie<'static>> {
+        if let Ok(value) = self.unseal(cookie.name(), cookie.value()) {
+            cookie.set_value(value);
+            return Some(cookie);
+        }
+
+        None
+    }
+}
+
+impl<J: Borrow<CookieJar>> PrivateJar<J> {
+    /// Returns a reference to the `Cookie` inside this jar with the name `name`
+    /// and authenticates and decrypts the cookie's value, returning a `Cookie`
+    /// with the decrypted value. If the cookie cannot be found, or the cookie
+    /// fails to authenticate or decrypt, `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let jar = CookieJar::new();
+    /// assert!(jar.private(&key).get("name").is_none());
+    ///
+    /// let mut jar = jar;
+    /// let mut private_jar = jar.private_mut(&key);
+    /// private_jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(private_jar.get("name").unwrap().value(), "value");
+    /// ```
+    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
+        self.parent.borrow().get(name).and_then(|c| self.decrypt(c.clone()))
+    }
+}
+
+impl<J: BorrowMut<CookieJar>> PrivateJar<J> {
+    /// Adds `cookie` to the parent jar. The cookie's value is encrypted with
+    /// authenticated encryption assuring confidentiality, integrity, and
+    /// authenticity.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.private_mut(&key).add(Cookie::new("name", "value"));
+    ///
+    /// assert_ne!(jar.get("name").unwrap().value(), "value");
+    /// assert_eq!(jar.private(&key).get("name").unwrap().value(), "value");
+    /// ```
+    pub fn add(&mut self, mut cookie: Cookie<'static>) {
+        self.encrypt_cookie(&mut cookie);
+        self.parent.borrow_mut().add(cookie);
+    }
+
+    /// Adds an "original" `cookie` to parent jar. The cookie's value is
+    /// encrypted with authenticated encryption assuring confidentiality,
+    /// integrity, and authenticity. Adding an original cookie does not affect
+    /// the [`CookieJar::delta()`] computation. This method is intended to be
+    /// used to seed the cookie jar with cookies received from a client's HTTP
+    /// message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.private_mut(&key).add_original(Cookie::new("name", "value"));
+    ///
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
+        self.encrypt_cookie(&mut cookie);
+        self.parent.borrow_mut().add_original(cookie);
+    }
+
+    /// Removes `cookie` from the parent jar.
+    ///
+    /// For correct removal, the passed in `cookie` must contain the same `path`
+    /// and `domain` as the cookie that was initially set.
+    ///
+    /// This is identical to [`CookieJar::remove()`]. See the method's
+    /// documentation for more details.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut private_jar = jar.private_mut(&key);
+    ///
+    /// private_jar.add(Cookie::new("name", "value"));
+    /// assert!(private_jar.get("name").is_some());
+    ///
+    /// private_jar.remove(Cookie::named("name"));
+    /// assert!(private_jar.get("name").is_none());
+    /// ```
+    pub fn remove(&mut self, cookie: Cookie<'static>) {
+        self.parent.borrow_mut().remove(cookie);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{CookieJar, Cookie, Key};
+
+    #[test]
+    fn simple() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_simple_behaviour!(jar, jar.private_mut(&key));
+    }
+
+    #[test]
+    fn secure() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_secure_behaviour!(jar, jar.private_mut(&key));
+    }
+
+    #[test]
+    fn roundtrip() {
+        // Secret is SHA-256 hash of 'Super secret!' passed through HKDF-SHA256.
+        let key = Key::from(&[89, 202, 200, 125, 230, 90, 197, 245, 166, 249,
+            34, 169, 135, 31, 20, 197, 94, 154, 254, 79, 60, 26, 8, 143, 254,
+            24, 116, 138, 92, 225, 159, 60, 157, 41, 135, 129, 31, 226, 196, 16,
+            198, 168, 134, 4, 42, 1, 196, 24, 57, 103, 241, 147, 201, 185, 233,
+            10, 180, 170, 187, 89, 252, 137, 110, 107]);
+
+        let mut jar = CookieJar::new();
+        jar.add(Cookie::new("encrypted_with_ring014",
+                "lObeZJorGVyeSWUA8khTO/8UCzFVBY9g0MGU6/J3NN1R5x11dn2JIA=="));
+        jar.add(Cookie::new("encrypted_with_ring016",
+                "SU1ujceILyMBg3fReqRmA9HUtAIoSPZceOM/CUpObROHEujXIjonkA=="));
+
+        let private = jar.private(&key);
+        assert_eq!(private.get("encrypted_with_ring014").unwrap().value(), "Tamper-proof");
+        assert_eq!(private.get("encrypted_with_ring016").unwrap().value(), "Tamper-proof");
+    }
+}
diff --git a/third_party/rust/cookie/src/secure/signed.rs b/third_party/rust/cookie/src/secure/signed.rs
new file mode 100644
index 0000000000..b46fae4e80
--- /dev/null
+++ b/third_party/rust/cookie/src/secure/signed.rs
@@ -0,0 +1,251 @@
+use std::convert::TryInto;
+use std::borrow::{Borrow, BorrowMut};
+
+use sha2::Sha256;
+use hmac::{Hmac, Mac};
+
+use crate::secure::{base64, Key};
+use crate::{Cookie, CookieJar};
+
+// Keep these in sync, and keep the key len synced with the `signed` docs as
+// well as the `KEYS_INFO` const in secure::Key.
+pub(crate) const BASE64_DIGEST_LEN: usize = 44;
+pub(crate) const KEY_LEN: usize = 32;
+
+/// A child cookie jar that authenticates its cookies.
+///
+/// A _signed_ child jar signs all the cookies added to it and verifies cookies
+/// retrieved from it. Any cookies stored in a `SignedJar` are provided
+/// integrity and authenticity. In other words, clients cannot tamper with the
+/// contents of a cookie nor can they fabricate cookie values, but the data is
+/// visible in plaintext.
+#[cfg_attr(all(nightly, doc), doc(cfg(feature = "signed")))]
+pub struct SignedJar<J> {
+    parent: J,
+    key: [u8; KEY_LEN],
+}
+
+impl<J> SignedJar<J> {
+    /// Creates a new child `SignedJar` with parent `parent` and key `key`. This
+    /// method is typically called indirectly via the `signed{_mut}` methods of
+    /// `CookieJar`.
+    pub(crate) fn new(parent: J, key: &Key) -> SignedJar<J> {
+        SignedJar { parent, key: key.signing().try_into().expect("sign key len") }
+    }
+
+    /// Signs the cookie's value providing integrity and authenticity.
+    fn sign_cookie(&self, cookie: &mut Cookie) {
+        // Compute HMAC-SHA256 of the cookie's value.
+        let mut mac = Hmac::<Sha256>::new_from_slice(&self.key).expect("good key");
+        mac.update(cookie.value().as_bytes());
+
+        // Cookie's new value is [MAC | original-value].
+        let mut new_value = base64::encode(&mac.finalize().into_bytes());
+        new_value.push_str(cookie.value());
+        cookie.set_value(new_value);
+    }
+
+    /// Given a signed value `str` where the signature is prepended to `value`,
+    /// verifies the signed value and returns it. If there's a problem, returns
+    /// an `Err` with a string describing the issue.
+    fn _verify(&self, cookie_value: &str) -> Result<String, &'static str> {
+        if !cookie_value.is_char_boundary(BASE64_DIGEST_LEN) {
+            return Err("missing or invalid digest");
+        }
+
+        // Split [MAC | original-value] into its two parts.
+        let (digest_str, value) = cookie_value.split_at(BASE64_DIGEST_LEN);
+        let digest = base64::decode(digest_str).map_err(|_| "bad base64 digest")?;
+
+        // Perform the verification.
+        let mut mac = Hmac::<Sha256>::new_from_slice(&self.key).expect("good key");
+        mac.update(value.as_bytes());
+        mac.verify_slice(&digest)
+            .map(|_| value.to_string())
+            .map_err(|_| "value did not verify")
+    }
+
+    /// Verifies the authenticity and integrity of `cookie`, returning the
+    /// plaintext version if verification succeeds or `None` otherwise.
+    /// Verification _always_ succeeds if `cookie` was generated by a
+    /// `SignedJar` with the same key as `self`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// assert!(jar.signed(&key).get("name").is_none());
+    ///
+    /// jar.signed_mut(&key).add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.signed(&key).get("name").unwrap().value(), "value");
+    ///
+    /// let plain = jar.get("name").cloned().unwrap();
+    /// assert_ne!(plain.value(), "value");
+    /// let verified = jar.signed(&key).verify(plain).unwrap();
+    /// assert_eq!(verified.value(), "value");
+    ///
+    /// let plain = Cookie::new("plaintext", "hello");
+    /// assert!(jar.signed(&key).verify(plain).is_none());
+    /// ```
+    pub fn verify(&self, mut cookie: Cookie<'static>) -> Option<Cookie<'static>> {
+        if let Ok(value) = self._verify(cookie.value()) {
+            cookie.set_value(value);
+            return Some(cookie);
+        }
+
+        None
+    }
+}
+
+impl<J: Borrow<CookieJar>> SignedJar<J> {
+    /// Returns a reference to the `Cookie` inside this jar with the name `name`
+    /// and verifies the authenticity and integrity of the cookie's value,
+    /// returning a `Cookie` with the authenticated value. If the cookie cannot
+    /// be found, or the cookie fails to verify, `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let jar = CookieJar::new();
+    /// assert!(jar.signed(&key).get("name").is_none());
+    ///
+    /// let mut jar = jar;
+    /// let mut signed_jar = jar.signed_mut(&key);
+    /// signed_jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(signed_jar.get("name").unwrap().value(), "value");
+    /// ```
+    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
+        self.parent.borrow().get(name).and_then(|c| self.verify(c.clone()))
+    }
+}
+
+impl<J: BorrowMut<CookieJar>> SignedJar<J> {
+    /// Adds `cookie` to the parent jar. The cookie's value is signed assuring
+    /// integrity and authenticity.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.signed_mut(&key).add(Cookie::new("name", "value"));
+    ///
+    /// assert_ne!(jar.get("name").unwrap().value(), "value");
+    /// assert!(jar.get("name").unwrap().value().contains("value"));
+    /// assert_eq!(jar.signed(&key).get("name").unwrap().value(), "value");
+    /// ```
+    pub fn add(&mut self, mut cookie: Cookie<'static>) {
+        self.sign_cookie(&mut cookie);
+        self.parent.borrow_mut().add(cookie);
+    }
+
+    /// Adds an "original" `cookie` to this jar. The cookie's value is signed
+    /// assuring integrity and authenticity. Adding an original cookie does not
+    /// affect the [`CookieJar::delta()`] computation. This method is intended
+    /// to be used to seed the cookie jar with cookies received from a client's
+    /// HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.signed_mut(&key).add_original(Cookie::new("name", "value"));
+    ///
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
+        self.sign_cookie(&mut cookie);
+        self.parent.borrow_mut().add_original(cookie);
+    }
+
+    /// Removes `cookie` from the parent jar.
+    ///
+    /// For correct removal, the passed in `cookie` must contain the same `path`
+    /// and `domain` as the cookie that was initially set.
+    ///
+    /// This is identical to [`CookieJar::remove()`]. See the method's
+    /// documentation for more details.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut signed_jar = jar.signed_mut(&key);
+    ///
+    /// signed_jar.add(Cookie::new("name", "value"));
+    /// assert!(signed_jar.get("name").is_some());
+    ///
+    /// signed_jar.remove(Cookie::named("name"));
+    /// assert!(signed_jar.get("name").is_none());
+    /// ```
+    pub fn remove(&mut self, cookie: Cookie<'static>) {
+        self.parent.borrow_mut().remove(cookie);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{CookieJar, Cookie, Key};
+
+    #[test]
+    fn simple() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_simple_behaviour!(jar, jar.signed_mut(&key));
+    }
+
+    #[test]
+    fn private() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_secure_behaviour!(jar, jar.signed_mut(&key));
+    }
+
+    #[test]
+    fn roundtrip() {
+        // Secret is SHA-256 hash of 'Super secret!' passed through HKDF-SHA256.
+        let key = Key::from(&[89, 202, 200, 125, 230, 90, 197, 245, 166, 249,
+            34, 169, 135, 31, 20, 197, 94, 154, 254, 79, 60, 26, 8, 143, 254,
+            24, 116, 138, 92, 225, 159, 60, 157, 41, 135, 129, 31, 226, 196, 16,
+            198, 168, 134, 4, 42, 1, 196, 24, 57, 103, 241, 147, 201, 185, 233,
+            10, 180, 170, 187, 89, 252, 137, 110, 107]);
+
+        let mut jar = CookieJar::new();
+        jar.add(Cookie::new("signed_with_ring014",
+                "3tdHXEQ2kf6fxC7dWzBGmpSLMtJenXLKrZ9cHkSsl1w=Tamper-proof"));
+        jar.add(Cookie::new("signed_with_ring016",
+                "3tdHXEQ2kf6fxC7dWzBGmpSLMtJenXLKrZ9cHkSsl1w=Tamper-proof"));
+
+        let signed = jar.signed(&key);
+        assert_eq!(signed.get("signed_with_ring014").unwrap().value(), "Tamper-proof");
+        assert_eq!(signed.get("signed_with_ring016").unwrap().value(), "Tamper-proof");
+    }
+
+    #[test]
+    fn issue_178() {
+        let data = "x=yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy£";
+        let c = Cookie::parse(data).expect("failed to parse cookie");
+        let key = Key::from(&[0u8; 64]);
+        let mut jar = CookieJar::new();
+        let signed = jar.signed_mut(&key);
+        assert!(signed.verify(c).is_none());
+    }
+}