net: Stop using both versions of the time crate in the cookie code (#33260)

`std::time` is good enough for us here. `cookie` is using `time 0.3`,
but Servo can convert to standard library types when getting data from
`cookie`. This reduces our direct dependencies and removes more use of
the very old `time 0.1` series.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>

components/net/Cargo.toml

@@ -57,7 +57,6 @@ servo_config = { path = "../config" }
 servo_url = { path = "../url" }
 sha2 = "0.10"
 time = { workspace = true }
-time_03 = { workspace = true }
 chrono = { workspace = true }
 tokio = { workspace = true, features = ["sync", "macros", "rt-multi-thread"] }
 tokio-rustls = { workspace = true }

components/net/cookie.rs

@@ -7,14 +7,13 @@
 
 use std::borrow::ToOwned;
 use std::net::{Ipv4Addr, Ipv6Addr};
+use std::time::{Duration, SystemTime};
 
 use cookie::Cookie;
 use net_traits::pub_domains::is_pub_domain;
 use net_traits::CookieSource;
 use serde::{Deserialize, Serialize};
 use servo_url::ServoUrl;
-use time::{now, Tm};
-use time_03::OffsetDateTime;
 
 /// A stored cookie that wraps the definition in cookie-rs. This is used to implement
 /// various behaviours defined in the spec that rely on an associated request URL,
@@ -28,17 +27,9 @@ pub struct ServoCookie {
     pub cookie: Cookie<'static>,
     pub host_only: bool,
     pub persistent: bool,
-    #[serde(
-        deserialize_with = "hyper_serde::deserialize",
-        serialize_with = "hyper_serde::serialize"
-    )]
-    pub creation_time: Tm,
-    #[serde(
-        deserialize_with = "hyper_serde::deserialize",
-        serialize_with = "hyper_serde::serialize"
-    )]
-    pub last_access: Tm,
-    pub expiry_time: Option<OffsetDateTime>,
+    pub creation_time: SystemTime,
+    pub last_access: SystemTime,
+    pub expiry_time: Option<SystemTime>,
 }
 
 impl ServoCookie {
@@ -60,9 +51,11 @@ impl ServoCookie {
         source: CookieSource,
     ) -> Option<ServoCookie> {
         // Step 3
-        let (persistent, expiry_time) = match (cookie.max_age(), cookie.expires_datetime()) {
-            (Some(max_age), _) => (true, Some(time_03::OffsetDateTime::now_utc() + max_age)),
-            (_, Some(date_time)) => (true, Some(date_time)),
+        let max_age: Option<Duration> =
+            cookie.max_age().and_then(|max_age| max_age.try_into().ok());
+        let (persistent, expiry_time) = match (max_age, cookie.expires_datetime()) {
+            (Some(max_age), _) => (true, Some(SystemTime::now() + max_age)),
+            (_, Some(date_time)) => (true, Some(date_time.into())),
             _ => (false, None),
         };
 
@@ -131,18 +124,18 @@ impl ServoCookie {
             cookie,
             host_only,
             persistent,
-            creation_time: now(),
-            last_access: now(),
+            creation_time: SystemTime::now(),
+            last_access: SystemTime::now(),
             expiry_time,
         })
     }
 
     pub fn touch(&mut self) {
-        self.last_access = now();
+        self.last_access = SystemTime::now();
     }
 
     pub fn set_expiry_time_in_past(&mut self) {
-        self.expiry_time = Some(time_03::OffsetDateTime::UNIX_EPOCH);
+        self.expiry_time = Some(SystemTime::UNIX_EPOCH)
     }
 
     // http://tools.ietf.org/html/rfc6265#section-5.1.4

components/net/cookie_storage.rs

@@ -8,14 +8,13 @@
 use std::cmp::Ordering;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::time::SystemTime;
 
 use log::{debug, info};
 use net_traits::pub_domains::reg_suffix;
 use net_traits::CookieSource;
 use serde::{Deserialize, Serialize};
 use servo_url::ServoUrl;
-use time::Tm;
-use time_03::OffsetDateTime;
 
 use crate::cookie::ServoCookie;
 
@@ -145,11 +144,7 @@ impl CookieStorage {
         let a_path_len = a.cookie.path().as_ref().map_or(0, |p| p.len());
         let b_path_len = b.cookie.path().as_ref().map_or(0, |p| p.len());
         match a_path_len.cmp(&b_path_len) {
-            Ordering::Equal => {
-                let a_creation_time = a.creation_time.to_timespec();
-                let b_creation_time = b.creation_time.to_timespec();
-                a_creation_time.cmp(&b_creation_time)
-            },
+            Ordering::Equal => a.creation_time.cmp(&b.creation_time),
             // Ensure that longer paths are sorted earlier than shorter paths
             Ordering::Greater => Ordering::Less,
             Ordering::Less => Ordering::Greater,
@@ -235,12 +230,12 @@ fn reg_host(url: &str) -> String {
 }
 
 fn is_cookie_expired(cookie: &ServoCookie) -> bool {
-    matches!(cookie.expiry_time, Some(date_time) if date_time <= OffsetDateTime::now_utc())
+    matches!(cookie.expiry_time, Some(date_time) if date_time <= SystemTime::now())
 }
 
 fn evict_one_cookie(is_secure_cookie: bool, cookies: &mut Vec<ServoCookie>) -> bool {
     // Remove non-secure cookie with oldest access time
-    let oldest_accessed: Option<(usize, Tm)> = get_oldest_accessed(false, cookies);
+    let oldest_accessed = get_oldest_accessed(false, cookies);
 
     if let Some((index, _)) = oldest_accessed {
         cookies.remove(index);
@@ -249,7 +244,7 @@ fn evict_one_cookie(is_secure_cookie: bool, cookies: &mut Vec<ServoCookie>) -> b
         if !is_secure_cookie {
             return false;
         }
-        let oldest_accessed: Option<(usize, Tm)> = get_oldest_accessed(true, cookies);
+        let oldest_accessed = get_oldest_accessed(true, cookies);
         if let Some((index, _)) = oldest_accessed {
             cookies.remove(index);
         }
@@ -257,13 +252,18 @@ fn evict_one_cookie(is_secure_cookie: bool, cookies: &mut Vec<ServoCookie>) -> b
     true
 }
 
-fn get_oldest_accessed(is_secure_cookie: bool, cookies: &mut [ServoCookie]) -> Option<(usize, Tm)> {
-    let mut oldest_accessed: Option<(usize, Tm)> = None;
+fn get_oldest_accessed(
+    is_secure_cookie: bool,
+    cookies: &mut [ServoCookie],
+) -> Option<(usize, SystemTime)> {
+    let mut oldest_accessed = None;
     for (i, c) in cookies.iter().enumerate() {
         if (c.cookie.secure().unwrap_or(false) == is_secure_cookie) &&
             oldest_accessed
                 .as_ref()
-                .map_or(true, |a| c.last_access < a.1)
+                .map_or(true, |(_, current_oldest_time)| {
+                    c.last_access < *current_oldest_time
+                })
         {
             oldest_accessed = Some((i, c.last_access));
         }