[DevTools] Save as HAR: classify time before network activity as "blocked".

Source/devtools/front_end/HAREntry.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 {
     this._request = request;
 }
 
 WebInspector.HAREntry.prototype = {
     /**
      * @return {Object}
      */
     build: function()
     {
-        var entry =  {
+        var entry = {
             startedDateTime: new Date(this._request.startTime * 1000),
-            time: WebInspector.HAREntry._toMilliseconds(this._request.duration),
+            time: this._request.timing ? WebInspector.HAREntry._toMilliseconds(this._request.duration) : 0,
             request: this._buildRequest(),
             response: this._buildResponse(),
             cache: { }, // Not supported yet.
             timings: this._buildTimings()
         };
+
         if (this._request.connectionId)
             entry.connection = String(this._request.connectionId);
         var page = WebInspector.networkLog.pageLoadForRequest(this._request);
         if (page)
             entry.pageref = "page_" + page.id;
         return entry;
     },
 
     /**
      * @return {Object}
@@ skipping 48 matching lines @@
         if (typeof compression === "number")
             content.compression = compression;
         return content;
     },
 
     /**
      * @return {Object}
      */
     _buildTimings: function()
     {
-        var waitForConnection = this._interval("connectStart", "connectEnd");
-        var blocked = 0;
+        // Order of events: request_start = 0, [proxy], [dns], [connect [ssl]], [send], receive_headers_end
+        // HAR 'blocked' time is time before first network activity.
+
+        var timing = this._request.timing;
+        if (!timing)
+            return {blocked: -1, dns: -1, connect: -1, send: 0, wait: 0, receive: 0, ssl: -1};
+
+        function nextEventTime(events) {

[caseq, 2013/09/13 15:24:07]

style: { => next line

[eustas, 2013/09/16 10:06:22]

Done.

+            for (var i = 0; i < events.length; ++i) {
+                if (timing[events[i]] > -1)

[caseq, 2013/09/13 15:24:07]

nit: -1 is a "null" value, so I think it would be better to either compare using
"!== -1" or ">= 0", not "> -1".

[eustas, 2013/09/16 10:06:22]

Done.

+                    return Math.round(timing[events[i]]);
+            }
+            return -1;
+        }
+
+        var blocked = nextEventTime(["dnsStart", "connectStart", "sendStart"]);
+
+        var dns = -1;
+        if (timing["dnsStart"] > -1)

[caseq, 2013/09/13 15:24:07]

Here ad below, why not timing.dnsStart? We should take advantage of js
compiler's type checking when we can.

[eustas, 2013/09/16 10:06:22]

Done.

+            dns = nextEventTime(["connectStart", "sendStart"]) - Math.round(timing["dnsStart"]);
+
         var connect = -1;
+        if (timing["connectStart"] > -1)
+            connect = Math.round(timing["sendStart"]) - Math.round(timing["connectStart"]);

[caseq, 2013/09/13 15:24:07]

On a closer look to the spec, do we really have to round times? They're
specified as "number".

[eustas, 2013/09/16 10:06:22]

Done.

 
-        if (this._request.connectionReused)
-            blocked = waitForConnection;
-        else
-            connect = waitForConnection;
+        var send = Math.round(timing["sendEnd"]) - Math.round(timing["sendStart"]);

[caseq, 2013/09/13 15:24:07]

Are we intentionally counting send time from sendStart, not from previous event?

[eustas, 2013/09/16 10:06:22]

Yes.

Last event (block, dns or connect) lasts till sendStart.

+        var wait = Math.round(timing["receiveHeadersEnd"]) - Math.round(timing["sendEnd"]);
+        var receive = WebInspector.HAREntry._toMilliseconds(this._request.duration) - Math.round(timing["receiveHeadersEnd"]);
 
-        return {
-            blocked: blocked,
-            dns: this._interval("dnsStart", "dnsEnd"),
-            connect: connect,
-            send: this._interval("sendStart", "sendEnd"),
-            wait: this._interval("sendEnd", "receiveHeadersEnd"),
-            receive: WebInspector.HAREntry._toMilliseconds(this._request.receiveDuration),
-            ssl: this._interval("sslStart", "sslEnd")
-        };
+        var ssl = -1;
+        if (timing["sslStart"] > -1 && timing["sslEnd"] > -1)
+            ssl = Math.round(timing["sslEnd"]) - Math.round(timing["sslStart"]);
+
+        return {blocked: blocked, dns: dns, connect: connect, send: send, wait: wait, receive: receive, ssl: ssl};
     },
 
     /**
      * @return {Object}
      */
     _buildPostData: function()
     {
         var res = {
             mimeType: this._request.requestHeaderValue("Content-Type"),
             text: this._request.requestFormData
@@ skipping 41 matching lines @@
             value: cookie.value(),
             path: cookie.path(),
             domain: cookie.domain(),
             expires: cookie.expiresDate(new Date(this._request.startTime * 1000)),
             httpOnly: cookie.httpOnly(),
             secure: cookie.secure()
         };
     },
 
     /**
-     * @param {string} start
-     * @param {string} end
-     * @return {number}
-     */
-    _interval: function(start, end)
-    {
-        var timing = this._request.timing;
-        if (!timing)
-            return -1;
-        var startTime = timing[start];
-        return typeof startTime !== "number" || startTime === -1 ? -1 : Math.round(timing[end] - startTime);
-    },
-
-    /**
      * @return {number}
      */
     get requestBodySize()
     {
         return !this._request.requestFormData ? 0 : this._request.requestFormData.length;
     },
 
     /**
      * @return {number}
      */
@@ skipping 190 matching lines @@
             this._writeProgress.done();
             return;
         }
         const chunkSize = 100000;
         var text = this._text.substring(this._bytesWritten, this._bytesWritten + chunkSize);
         this._bytesWritten += text.length;
         stream.write(text, this._writeNextChunk.bind(this));
         this._writeProgress.setWorked(this._bytesWritten);
     }
 }