perf_hooks: add markResourceTiming

RafaelGSS · RafaelGSS · commit b72814917ef4 · 2022-04-12T23:44:19.000-03:00
diff --git a/lib/internal/perf/performance.js b/lib/internal/perf/performance.js
@@ -19,6 +19,8 @@ const {
 
 const { now } = require('internal/perf/utils');
 
+const { markResourceTiming } = require('internal/perf/resource_timing');
+
 const {
   mark,
   measure,
@@ -164,6 +166,11 @@ ObjectDefineProperties(Performance.prototype, {
     enumerable: false,
     value: nodeTiming,
   },
+  markResourceTiming: {
+    configurable: true,
+    enumerable: false,
+    value: markResourceTiming,
+  },
   now: {
     configurable: true,
     enumerable: false,
diff --git a/lib/internal/perf/resource_timing.js b/lib/internal/perf/resource_timing.js
@@ -4,6 +4,7 @@
 const { InternalPerformanceEntry } = require('internal/perf/performance_entry');
 const { SymbolToStringTag } = primordials;
 const assert = require('assert')
+const { enqueue } = require('internal/perf/observe');
 
 const kCacheMode = Symbol('kCacheMode');
 const kRequestedUrl = Symbol('kRequestedUrl');
@@ -12,7 +13,7 @@ const kInitiatorType = Symbol('kInitiatorType');
 
 class PerformanceResourceTiming extends InternalPerformanceEntry {
   constructor(requestedUrl, start, initiatorType, timingInfo, cacheMode = "") {
-    super(requestedUrl, 'resource', start, duration);
+    super(requestedUrl, 'resource', start);
     // https://w3c.github.io/resource-timing/#dfn-setup-the-resource-timing-entry
     assert.ok(cacheMode === "" || cacheMode === "local")
     this[kInitiatorType] = initiatorType
@@ -104,7 +105,6 @@ class PerformanceResourceTiming extends InternalPerformanceEntry {
     if (this[kCacheMode] === 'local') return 0;
     if (this[kCacheMode] === 'validated') return 300;
 
-    // TODO: it might return NaN
     return this[kTimingInfo].encodedBodySize + 300;
   }
 
@@ -122,6 +122,35 @@ class PerformanceResourceTiming extends InternalPerformanceEntry {
   }
 }
 
+// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing
+function markResourceTiming(
+  timingInfo,
+  requestedUrl,
+  initiatorType,
+  global,
+  cacheMode
+) {
+  // TODO(rafaelgss): Probably must have some asserts here for:
+  // - timingInfo
+  // - requestedUrl
+  // - initiatorType
+  // - cacheMode
+ 
+  // 1. Create a PerformanceResourceTiming object entry in global's realm.
+  // TODO(rafaelgss): why and how should I put `resource` into global object?
+  const resource = new PerformanceResourceTiming(
+    requestedUrl,
+    // TODO(rafaelgss): not sure about that
+    timingInfo.startTime,
+    initiatorType,
+    timingInfo,
+    cacheMode
+  );
+  enqueue(resource);
+  return resource;
+}
+
 module.exports = {
   PerformanceResourceTiming,
+  markResourceTiming,
 };
diff --git a/test/parallel/test-perf-hooks-resourcetiming.js b/test/parallel/test-perf-hooks-resourcetiming.js
@@ -1,18 +1,127 @@
 'use strict';
 
+const common = require('../common');
 const assert = require('assert');
 const {
   PerformanceObserver,
   PerformanceEntry,
   PerformanceResourceTiming,
   performance: {
-    clearResourceTimings
+    clearResourceTimings,
+    markResourceTiming,
   },
 } = require('perf_hooks');
 
 assert(PerformanceObserver);
 assert(PerformanceEntry);
 assert(PerformanceResourceTiming);
 assert(clearResourceTimings);
+assert(markResourceTiming);
 
-// TODO:continue once `markResourceTiming` is done
+function createTimingInfo({
+  startTime = 0,
+  redirectStartTime = 0,
+  redirectEndTime = 0,
+  postRedirectStartTime = 0,
+  finalServiceWorkerStartTime = 0,
+  finalNetworkRequestStartTime = 0,
+  finalNetworkResponseStartTime = 0,
+  endTime = 0,
+  encodedBodySize = 0,
+  decodedBodySize = 0,
+  finalConnectionTimingInfo = null
+}) {
+  if (finalConnectionTimingInfo !== null) {
+    finalConnectionTimingInfo.domainLookupStartTime =
+        finalConnectionTimingInfo.domainLookupStartTime || 0
+    finalConnectionTimingInfo.domainLookupEndTime =
+        finalConnectionTimingInfo.domainLookupEndTime || 0
+    finalConnectionTimingInfo.connectionStartTime =
+        finalConnectionTimingInfo.connectionStartTime || 0
+    finalConnectionTimingInfo.connectionEndTime =
+        finalConnectionTimingInfo.connectionEndTime || 0
+    finalConnectionTimingInfo.secureConnectionStartTime =
+        finalConnectionTimingInfo.secureConnectionStartTime || 0
+    finalConnectionTimingInfo.ALPNNegotiatedProtocol =
+        finalConnectionTimingInfo.ALPNNegotiatedProtocol || []
+  }
+  return {
+    startTime,
+    redirectStartTime,
+    redirectEndTime,
+    postRedirectStartTime,
+    finalServiceWorkerStartTime,
+    finalNetworkRequestStartTime,
+    finalNetworkResponseStartTime,
+    endTime,
+    encodedBodySize,
+    decodedBodySize,
+    finalConnectionTimingInfo,
+  }
+}
+
+{
+  const obs = new PerformanceObserver(common.mustCall((list) => {
+    {
+      const entries = list.getEntries();
+      assert.strictEqual(entries.length, 1);
+    }
+    {
+      const entries = list.getEntriesByType('resource');
+      assert.strictEqual(entries.length, 1);
+    }
+    {
+      const entries = list.getEntriesByName('http://localhost:8080');
+      assert.strictEqual(entries.length, 1);
+    }
+    obs.disconnect();
+  }));
+  obs.observe({ entryTypes: ['resource'] });
+
+  const timingInfo = createTimingInfo({ finalConnectionTimingInfo: {} });
+  const customGlobal = {};
+  const requestedUrl = 'http://localhost:8080';
+  const cacheMode = 'local';
+  const initiatorType = 'fetch';
+  const resource = markResourceTiming(
+    timingInfo,
+    requestedUrl,
+    initiatorType,
+    customGlobal,
+    cacheMode,
+  );
+
+  assert(resource instanceof PerformanceEntry);
+  assert(resource instanceof PerformanceResourceTiming);
+
+  assert.strictEqual(resource.entryType, 'resource');
+  assert.strictEqual(resource.name, requestedUrl);
+  assert.ok(typeof resource.cacheMode === 'undefined', 'cacheMode does not have a getter');
+  assert.strictEqual(resource.startTime, timingInfo.startTime);
+  assert.strictEqual(resource.duration, 0);
+  assert.strictEqual(resource.workerStart, 0);
+  assert.strictEqual(resource.redirectStart, 0);
+  assert.strictEqual(resource.redirectEnd, 0);
+  assert.strictEqual(resource.fetchStart, 0);
+  assert.strictEqual(resource.domainLookupStart, 0);
+  assert.strictEqual(resource.domainLookupEnd, 0);
+  assert.strictEqual(resource.connectStart, 0);
+  assert.strictEqual(resource.connectEnd, 0);
+  assert.strictEqual(resource.secureConnectionStart, 0);
+  assert.deepEqual(resource.nextHopProtocol, []);
+  assert.strictEqual(resource.requestStart, 0);
+  assert.strictEqual(resource.responseStart, 0);
+  assert.strictEqual(resource.responseEnd, 0);
+  assert.strictEqual(resource.encodedBodySize, 0);
+  assert.strictEqual(resource.decodedBodySize, 0);
+  assert.strictEqual(resource.transferSize, 0);
+  assert.deepEqual(resource.toJSON(), {
+    initiatorType,
+    requestedUrl,
+    cacheMode,
+    name: requestedUrl,
+    entryType: 'resource',
+    startTime: timingInfo.startTime,
+    duration: 0
+  });
+}
