[DevTools] Extract NetworkLog and HAREntry to a separate network_log module

third_party/WebKit/Source/devtools/front_end/network_log/NetworkLog.js

 /*
  * Copyright (C) 2011 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @implements {SDK.SDKModelObserver<!SDK.NetworkManager>}
  */
-SDK.NetworkLog = class {
+NetworkLog.NetworkLog = class {
   constructor() {
     /** @type {!Array<!SDK.NetworkRequest>} */
     this._requests = [];
     /** @type {!Map<!SDK.Target, !Map<string, !SDK.NetworkRequest>>} */
     this._requestsByTargetAndId = new Map();
-    /** @type {!Map<!SDK.Target, !SDK.PageLoad>} */
+    /** @type {!Map<!SDK.Target, !NetworkLog.PageLoad>} */
     this._currentPageLoad = new Map();
     SDK.targetManager.observeModels(SDK.NetworkManager, this);
   }
 
   /**
    * @override
    * @param {!SDK.NetworkManager} networkManager
    */
   modelAdded(networkManager) {
     var eventListeners = [];
     eventListeners.push(
         networkManager.addEventListener(SDK.NetworkManager.Events.RequestStarted, this._onRequestStarted, this));
     eventListeners.push(networkManager.on(SDK.NetworkManager.RequestRedirectEvent, this._onRequestRedirect, this));
 
     var resourceTreeModel = networkManager.target().model(SDK.ResourceTreeModel);
     if (resourceTreeModel) {
       eventListeners.push(resourceTreeModel.addEventListener(
           SDK.ResourceTreeModel.Events.MainFrameNavigated, this._onMainFrameNavigated, this));
       eventListeners.push(resourceTreeModel.addEventListener(
           SDK.ResourceTreeModel.Events.Load, this._onLoad.bind(this, resourceTreeModel)));
       eventListeners.push(resourceTreeModel.addEventListener(
           SDK.ResourceTreeModel.Events.DOMContentLoaded, this._onDOMContentLoaded.bind(this, resourceTreeModel)));
     }
 
-    networkManager[SDK.NetworkLog._events] = eventListeners;
+    networkManager[NetworkLog.NetworkLog._events] = eventListeners;
     this._requestsByTargetAndId.set(networkManager.target(), new Map());
   }
 
   /**
    * @override
    * @param {!SDK.NetworkManager} networkManager
    */
   modelRemoved(networkManager) {
     this._requestsByTargetAndId.delete(networkManager.target());
-    Common.EventTarget.removeEventListeners(networkManager[SDK.NetworkLog._events]);
+    Common.EventTarget.removeEventListeners(networkManager[NetworkLog.NetworkLog._events]);
   }
 
   /**
    * @param {string} url
    * @return {?SDK.NetworkRequest}
    */
   requestForURL(url) {
     return this._requests.find(request => request.url() === url) || null;
   }
 
@@ skipping 26 matching lines @@
       if (request.url() === url)
         return request;
     }
     return null;
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
    */
   _initializeInitiatorSymbolIfNeeded(request) {
-    if (!request[SDK.NetworkLog._initiatorDataSymbol]) {
-      /** @type {!{info: ?SDK.NetworkLog._InitiatorInfo, chain: !Set<!SDK.NetworkRequest>, request: (?SDK.NetworkRequest|undefined)}} */
-      request[SDK.NetworkLog._initiatorDataSymbol] = {
+    if (!request[NetworkLog.NetworkLog._initiatorDataSymbol]) {
+      /** @type {!{info: ?NetworkLog.NetworkLog._InitiatorInfo, chain: !Set<!SDK.NetworkRequest>, request: (?SDK.NetworkRequest|undefined)}} */
+      request[NetworkLog.NetworkLog._initiatorDataSymbol] = {
         info: null,
         chain: null,
         request: undefined,
       };
     }
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
-   * @return {!SDK.NetworkLog._InitiatorInfo}
+   * @return {!NetworkLog.NetworkLog._InitiatorInfo}
    */
   initiatorInfoForRequest(request) {
     this._initializeInitiatorSymbolIfNeeded(request);
-    if (request[SDK.NetworkLog._initiatorDataSymbol].info)
-      return request[SDK.NetworkLog._initiatorDataSymbol].info;
+    if (request[NetworkLog.NetworkLog._initiatorDataSymbol].info)
+      return request[NetworkLog.NetworkLog._initiatorDataSymbol].info;
 
     var type = SDK.NetworkRequest.InitiatorType.Other;
     var url = '';
     var lineNumber = -Infinity;
     var columnNumber = -Infinity;
     var scriptId = null;
     var initiator = request.initiator();
 
     if (request.redirectSource) {
       type = SDK.NetworkRequest.InitiatorType.Redirect;
@@ skipping 13 matching lines @@
           lineNumber = topFrame.lineNumber;
           columnNumber = topFrame.columnNumber;
           scriptId = topFrame.scriptId;
           break;
         }
       } else if (initiator.type === Protocol.Network.InitiatorType.Preload) {
         type = SDK.NetworkRequest.InitiatorType.Preload;
       }
     }
 
-    request[SDK.NetworkLog._initiatorDataSymbol].info =
+    request[NetworkLog.NetworkLog._initiatorDataSymbol].info =
         {type: type, url: url, lineNumber: lineNumber, columnNumber: columnNumber, scriptId: scriptId};
-    return request[SDK.NetworkLog._initiatorDataSymbol].info;
+    return request[NetworkLog.NetworkLog._initiatorDataSymbol].info;
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
-   * @return {!SDK.NetworkLog.InitiatorGraph}
+   * @return {!NetworkLog.NetworkLog.InitiatorGraph}
    */
   initiatorGraphForRequest(request) {
     /** @type {!Set<!SDK.NetworkRequest>} */
     var initiated = new Set();
     var map = this._requestsByTargetAndId.get(request.target());
     if (map) {
       for (var otherRequest of map.values()) {
         if (this._initiatorChain(otherRequest).has(request))
           initiated.add(otherRequest);
       }
     }
     return {initiators: this._initiatorChain(request), initiated: initiated};
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
    * @return {!Set<!SDK.NetworkRequest>}
    */
   _initiatorChain(request) {
     this._initializeInitiatorSymbolIfNeeded(request);
     var initiatorChainCache =
-        /** @type {?Set<!SDK.NetworkRequest>} */ (request[SDK.NetworkLog._initiatorDataSymbol].chain);
+        /** @type {?Set<!SDK.NetworkRequest>} */ (request[NetworkLog.NetworkLog._initiatorDataSymbol].chain);
     if (initiatorChainCache)
       return initiatorChainCache;
 
     initiatorChainCache = new Set();
 
     var checkRequest = request;
     do {
       initiatorChainCache.add(checkRequest);
       checkRequest = this._initiatorRequest(checkRequest);
     } while (checkRequest);
-    request[SDK.NetworkLog._initiatorDataSymbol].chain = initiatorChainCache;
+    request[NetworkLog.NetworkLog._initiatorDataSymbol].chain = initiatorChainCache;
     return initiatorChainCache;
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
    * @return {?SDK.NetworkRequest}
    */
   _initiatorRequest(request) {
     this._initializeInitiatorSymbolIfNeeded(request);
-    if (request[SDK.NetworkLog._initiatorDataSymbol].request !== undefined)
-      return request[SDK.NetworkLog._initiatorDataSymbol].request;
+    if (request[NetworkLog.NetworkLog._initiatorDataSymbol].request !== undefined)
+      return request[NetworkLog.NetworkLog._initiatorDataSymbol].request;
     var url = this.initiatorInfoForRequest(request).url;
-    request[SDK.NetworkLog._initiatorDataSymbol].request = this._requestForURLInTarget(url, request.target());
-    return request[SDK.NetworkLog._initiatorDataSymbol].request;
+    request[NetworkLog.NetworkLog._initiatorDataSymbol].request = this._requestForURLInTarget(url, request.target());
+    return request[NetworkLog.NetworkLog._initiatorDataSymbol].request;
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
-   * @return {?SDK.PageLoad}
+   * @return {?NetworkLog.PageLoad}
    */
   pageLoadForRequest(request) {
-    return request[SDK.NetworkLog._pageLoadForRequestSymbol];
+    return request[NetworkLog.NetworkLog._pageLoadForRequestSymbol];
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onMainFrameNavigated(event) {
     var mainFrame = /** @type {!SDK.ResourceTreeFrame} */ (event.data);
     var target = mainFrame.target();
     this._currentPageLoad.delete(target);
     var oldRequests = this.requestsForTarget(target);
     this._requests = this._requests.filter(request => request.target() !== target);
     var idMap = new Map();
     this._requestsByTargetAndId.set(target, idMap);
 
     // Preserve requests from the new session.
     var currentPageLoad = null;
     for (var i = 0; i < oldRequests.length; ++i) {
       var request = oldRequests[i];
       if (request.loaderId === mainFrame.loaderId) {
         if (!currentPageLoad)
-          currentPageLoad = new SDK.PageLoad(request);
+          currentPageLoad = new NetworkLog.PageLoad(request);
         this._requests.push(request);
         idMap.set(request.requestId(), request);
-        request[SDK.NetworkLog._pageLoadForRequestSymbol] = currentPageLoad;
+        request[NetworkLog.NetworkLog._pageLoadForRequestSymbol] = currentPageLoad;
       }
     }
     if (currentPageLoad)
       this._currentPageLoad.set(target, currentPageLoad);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onRequestStarted(event) {
     var request = /** @type {!SDK.NetworkRequest} */ (event.data);
     this._requests.push(request);
     this._requestsByTargetAndId.get(request.target()).set(request.requestId(), request);
-    request[SDK.NetworkLog._pageLoadForRequestSymbol] = this._currentPageLoad.get(request.target());
+    request[NetworkLog.NetworkLog._pageLoadForRequestSymbol] = this._currentPageLoad.get(request.target());
   }
 
   /**
    * @param {!SDK.NetworkManager.RequestRedirectEvent} event
    */
   _onRequestRedirect(event) {
     var request = event.request;
-    delete request[SDK.NetworkLog._initiatorDataSymbol];
+    delete request[NetworkLog.NetworkLog._initiatorDataSymbol];
   }
 
   /**
    * @param {!SDK.ResourceTreeModel} resourceTreeModel
    * @param {!Common.Event} event
    */
   _onDOMContentLoaded(resourceTreeModel, event) {
     var pageLoad = this._currentPageLoad.get(resourceTreeModel.target());
     if (pageLoad)
       pageLoad.contentLoadTime = /** @type {number} */ (event.data);
@@ skipping 13 matching lines @@
    * @param {!SDK.Target} target
    * @param {!Protocol.Network.RequestId} requestId
    * @return {?SDK.NetworkRequest}
    */
   requestForId(target, requestId) {
     var map = this._requestsByTargetAndId.get(target);
     return map ? (map.get(requestId) || null) : null;
   }
 };
 
-SDK.PageLoad = class {
+NetworkLog.PageLoad = class {
   /**
    * @param {!SDK.NetworkRequest} mainRequest
    */
   constructor(mainRequest) {
-    this.id = ++SDK.PageLoad._lastIdentifier;
+    this.id = ++NetworkLog.PageLoad._lastIdentifier;
     this.url = mainRequest.url();
     this.startTime = mainRequest.startTime;
     /** @type {number} */
     this.loadTime;
     /** @type {number} */
     this.contentLoadTime;
   }
 };
 
-SDK.PageLoad._lastIdentifier = 0;
+NetworkLog.PageLoad._lastIdentifier = 0;
 
 /** @typedef {!{initiators: !Set<!SDK.NetworkRequest>, initiated: !Set<!SDK.NetworkRequest>}} */
-SDK.NetworkLog.InitiatorGraph;
+NetworkLog.NetworkLog.InitiatorGraph;
 
 /** @typedef {!{type: !SDK.NetworkRequest.InitiatorType, url: string, lineNumber: number, columnNumber: number, scriptId: ?string}} */
-SDK.NetworkLog._InitiatorInfo;
+NetworkLog.NetworkLog._InitiatorInfo;
 
-SDK.NetworkLog._initiatorDataSymbol = Symbol('InitiatorData');
-SDK.NetworkLog._pageLoadForRequestSymbol = Symbol('PageLoadForRequest');
-SDK.NetworkLog._events = Symbol('SDK.NetworkLog.events');
+NetworkLog.NetworkLog._initiatorDataSymbol = Symbol('InitiatorData');
+NetworkLog.NetworkLog._pageLoadForRequestSymbol = Symbol('PageLoadForRequest');
+NetworkLog.NetworkLog._events = Symbol('NetworkLog.NetworkLog.events');
 
-/** @type {!SDK.NetworkLog} */
-SDK.networkLog;
+/** @type {!NetworkLog.NetworkLog} */
+NetworkLog.networkLog;