Add start_time to resource timing.

components/net_traits/lib.rs

@@ -474,6 +474,7 @@ pub struct ResourceFetchTiming {
     pub redirect_end: u64,
     pub connect_start: u64,
     pub connect_end: u64,
+    pub start_time: u64,
 }
 
 pub enum RedirectStartValue {
@@ -487,6 +488,15 @@ pub enum RedirectEndValue {
     ResponseEnd,
 }
 
+// TODO: refactor existing code to use this enum for setting time attributes
+// suggest using this with all time attributes in the future
+pub enum ResourceTimeValue {
+    Zero,
+    Now,
+    FetchStart,
+    RedirectStart,
+}
+
 pub enum ResourceAttribute {
     RedirectCount(u16),
     DomainLookupStart,
@@ -499,6 +509,7 @@ pub enum ResourceAttribute {
     ConnectEnd(u64),
     SecureConnectionStart,
     ResponseEnd,
+    StartTime(ResourceTimeValue),
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
@@ -525,6 +536,7 @@ impl ResourceFetchTiming {
             connect_start: 0,
             connect_end: 0,
             response_end: 0,
+            start_time: 0,
         }
     }
 
@@ -532,7 +544,9 @@ impl ResourceFetchTiming {
     // time origin (as described in Performance::now)
     pub fn set_attribute(&mut self, attribute: ResourceAttribute) {
         let should_attribute_always_be_updated = match attribute {
-            ResourceAttribute::FetchStart | ResourceAttribute::ResponseEnd => true,
+            ResourceAttribute::FetchStart |
+            ResourceAttribute::ResponseEnd |
+            ResourceAttribute::StartTime(_) => true,
             _ => false,
         };
         if !self.timing_check_passed && !should_attribute_always_be_updated {
@@ -562,6 +576,20 @@ impl ResourceFetchTiming {
                 self.secure_connection_start = precise_time_ns()
             },
             ResourceAttribute::ResponseEnd => self.response_end = precise_time_ns(),
+            ResourceAttribute::StartTime(val) => match val {
+                ResourceTimeValue::RedirectStart
+                    if self.redirect_start == 0 || !self.timing_check_passed => {},
+                _ => self.start_time = self.get_time_value(val),
+            },
+        }
+    }
+
+    fn get_time_value(&self, time: ResourceTimeValue) -> u64 {
+        match time {
+            ResourceTimeValue::Zero => 0,
+            ResourceTimeValue::Now => precise_time_ns(),
+            ResourceTimeValue::FetchStart => self.fetch_start,
+            ResourceTimeValue::RedirectStart => self.redirect_start,
         }
     }
 

components/net_traits/tests/lib.rs

@@ -0,0 +1,215 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use net_traits::{ResourceAttribute, ResourceFetchTiming, ResourceTimeValue, ResourceTimingType};
+
+#[test]
+fn test_set_start_time_to_fetch_start_if_nonzero_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.fetch_start = 1;
+    assert_eq!(resource_timing.start_time, 0, "`start_time` should be zero");
+    assert!(
+        resource_timing.fetch_start > 0,
+        "`fetch_start` should have a positive value"
+    );
+
+    // verify that setting `start_time` to `fetch_start` succeeds
+    resource_timing.set_attribute(ResourceAttribute::StartTime(ResourceTimeValue::FetchStart));
+    assert_eq!(
+        resource_timing.start_time, resource_timing.fetch_start,
+        "`start_time` should equal `fetch_start`"
+    );
+}
+
+#[test]
+fn test_set_start_time_to_fetch_start_if_zero_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.start_time = 1;
+    assert!(
+        resource_timing.start_time > 0,
+        "`start_time` should have a positive value"
+    );
+    assert_eq!(
+        resource_timing.fetch_start, 0,
+        "`fetch_start` should be zero"
+    );
+
+    // verify that setting `start_time` to `fetch_start` succeeds even when `fetch_start` == zero
+    resource_timing.set_attribute(ResourceAttribute::StartTime(ResourceTimeValue::FetchStart));
+    assert_eq!(
+        resource_timing.start_time, resource_timing.fetch_start,
+        "`start_time` should equal `fetch_start`"
+    );
+}
+
+#[test]
+fn test_set_start_time_to_fetch_start_if_nonzero_no_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.mark_timing_check_failed();
+    resource_timing.fetch_start = 1;
+    assert_eq!(resource_timing.start_time, 0, "`start_time` should be zero");
+    assert!(
+        resource_timing.fetch_start > 0,
+        "`fetch_start` should have a positive value"
+    );
+
+    // verify that setting `start_time` to `fetch_start` succeeds even when TAO check failed
+    resource_timing.set_attribute(ResourceAttribute::StartTime(ResourceTimeValue::FetchStart));
+    assert_eq!(
+        resource_timing.start_time, resource_timing.fetch_start,
+        "`start_time` should equal `fetch_start`"
+    );
+}
+
+#[test]
+fn test_set_start_time_to_fetch_start_if_zero_no_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.mark_timing_check_failed();
+    resource_timing.start_time = 1;
+    assert!(
+        resource_timing.start_time > 0,
+        "`start_time` should have a positive value"
+    );
+    assert_eq!(
+        resource_timing.fetch_start, 0,
+        "`fetch_start` should be zero"
+    );
+
+    // verify that setting `start_time` to `fetch_start` succeeds even when `fetch_start`==0 and no TAO
+    resource_timing.set_attribute(ResourceAttribute::StartTime(ResourceTimeValue::FetchStart));
+    assert_eq!(
+        resource_timing.start_time, resource_timing.fetch_start,
+        "`start_time` should equal `fetch_start`"
+    );
+}
+
+#[test]
+fn test_set_start_time_to_redirect_start_if_nonzero_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.redirect_start = 1;
+    assert_eq!(resource_timing.start_time, 0, "`start_time` should be zero");
+    assert!(
+        resource_timing.redirect_start > 0,
+        "`redirect_start` should have a positive value"
+    );
+
+    // verify that setting `start_time` to `redirect_start` succeeds for nonzero `redirect_start`, TAO pass
+    resource_timing.set_attribute(ResourceAttribute::StartTime(
+        ResourceTimeValue::RedirectStart,
+    ));
+    assert_eq!(
+        resource_timing.start_time, resource_timing.redirect_start,
+        "`start_time` should equal `redirect_start`"
+    );
+}
+
+#[test]
+fn test_not_set_start_time_to_redirect_start_if_zero_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.start_time = 1;
+    assert!(
+        resource_timing.start_time > 0,
+        "`start_time` should have a positive value"
+    );
+    assert_eq!(
+        resource_timing.redirect_start, 0,
+        "`redirect_start` should be zero"
+    );
+
+    // verify that setting `start_time` to `redirect_start` fails if `redirect_start` == 0
+    resource_timing.set_attribute(ResourceAttribute::StartTime(
+        ResourceTimeValue::RedirectStart,
+    ));
+    assert_ne!(
+        resource_timing.start_time, resource_timing.redirect_start,
+        "`start_time` should *not* equal `redirect_start`"
+    );
+}
+
+#[test]
+fn test_not_set_start_time_to_redirect_start_if_nonzero_no_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.mark_timing_check_failed();
+    // Note: properly-behaved redirect_start should never be nonzero once TAO check has failed
+    resource_timing.redirect_start = 1;
+    assert_eq!(resource_timing.start_time, 0, "`start_time` should be zero");
+    assert!(
+        resource_timing.redirect_start > 0,
+        "`redirect_start` should have a positive value"
+    );
+
+    // verify that setting `start_time` to `redirect_start` fails if TAO check fails
+    resource_timing.set_attribute(ResourceAttribute::StartTime(
+        ResourceTimeValue::RedirectStart,
+    ));
+    assert_ne!(
+        resource_timing.start_time, resource_timing.redirect_start,
+        "`start_time` should *not* equal `redirect_start`"
+    );
+}
+
+#[test]
+fn test_not_set_start_time_to_redirect_start_if_zero_no_tao() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    resource_timing.mark_timing_check_failed();
+    resource_timing.start_time = 1;
+    assert!(
+        resource_timing.start_time > 0,
+        "`start_time` should have a positive value"
+    );
+    assert_eq!(
+        resource_timing.redirect_start, 0,
+        "`redirect_start` should be zero"
+    );
+
+    // verify that setting `start_time` to `redirect_start` fails if `redirect_start`==0 and no TAO
+    resource_timing.set_attribute(ResourceAttribute::StartTime(
+        ResourceTimeValue::RedirectStart,
+    ));
+    assert_ne!(
+        resource_timing.start_time, resource_timing.redirect_start,
+        "`start_time` should *not* equal `redirect_start`"
+    );
+}
+
+#[test]
+fn test_set_start_time() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    assert_eq!(
+        resource_timing.start_time, 0,
+        "initial `start_time` should be zero"
+    );
+
+    // verify setting `start_time` to current time succeeds
+    resource_timing.set_attribute(ResourceAttribute::StartTime(ResourceTimeValue::Now));
+    assert!(resource_timing.start_time > 0, "failed to set `start_time`");
+}
+#[test]
+fn test_reset_start_time() {
+    let mut resource_timing: ResourceFetchTiming =
+        ResourceFetchTiming::new(ResourceTimingType::Resource);
+    assert_eq!(resource_timing.start_time, 0, "initial `start_time` = 0");
+
+    resource_timing.start_time = 1;
+    assert!(
+        resource_timing.start_time > 0,
+        "`start_time` should have a positive value"
+    );
+
+    // verify resetting `start_time` (to zero) succeeds
+    resource_timing.set_attribute(ResourceAttribute::StartTime(ResourceTimeValue::Zero));
+    assert_eq!(
+        resource_timing.start_time, 0,
+        "failed to reset `start_time`"
+    );
+}