[Devtools] NetworkLogView now uses NetworkLog as source of truth.

third_party/WebKit/Source/devtools/front_end/network/NetworkLogView.js

 /*
  * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2008, 2009 Anthony Ricaud <rik@webkit.org>
  * 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 53 matching lines @@
     function updateRowHeight() {
       /** @type {number} */
       this._rawRowHeight = !!this._networkLogLargeRowsSetting.get() ? 41 : 21;
       this._updateRowHeight();
     }
     updateRowHeight.call(this);
 
     this._columns = new Network.NetworkLogViewColumns(
         this, this._timeCalculator, this._durationCalculator, networkLogLargeRowsSetting);
 
-    /** @type {!Map.<string, !Network.NetworkRequestNode>} */
-    this._nodesByRequestId = new Map();
-    /** @type {!Object.<string, boolean>} */
-    this._staleRequestIds = {};
+    /** @type {!Set<!SDK.NetworkRequest>} */
+    this._staleRequests = new Set();
+    /** @type {!Set<!SDK.NetworkRequest>} */
+    this._nodesToRemove = new Set();
     /** @type {number} */
     this._mainRequestLoadTime = -1;
     /** @type {number} */
     this._mainRequestDOMContentLoadedTime = -1;
     this._matchedRequestCount = 0;
     this._highlightedSubstringChanges = [];
 
     /** @type {!Array.<!Network.NetworkLogView.Filter>} */
     this._filters = [];
     /** @type {?Network.NetworkLogView.Filter} */
@@ skipping 19 matching lines @@
     this._activeGroupLookup = null;
 
     this._addFilters();
     this._resetSuggestionBuilder();
     this._initializeView();
 
     Common.moduleSetting('networkColorCodeResourceTypes')
         .addChangeListener(this._invalidateAllItems.bind(this, false), this);
 
     SDK.targetManager.observeModels(SDK.NetworkManager, this);
-    SDK.targetManager.addModelListener(
-        SDK.NetworkManager, SDK.NetworkManager.Events.RequestStarted, this._onRequestStarted, this);
-    SDK.targetManager.addModelListener(
-        SDK.NetworkManager, SDK.NetworkManager.Events.RequestUpdated, this._onRequestUpdated, this);
-    SDK.targetManager.addModelListener(
-        SDK.NetworkManager, SDK.NetworkManager.Events.RequestFinished, this._onRequestUpdated, this);
+    NetworkLog.networkLog.addEventListener(NetworkLog.NetworkLog.Events.RequestAdded, this._onRequestUpdated, this);
+    NetworkLog.networkLog.addEventListener(NetworkLog.NetworkLog.Events.RequestUpdated, this._onRequestUpdated, this);
+    NetworkLog.networkLog.addEventListener(NetworkLog.NetworkLog.Events.Reset, this._reset, this);
+    NetworkLog.networkLog.addEventListener(NetworkLog.NetworkLog.Events.RequestsRemoved, this._onRequestsRemoved, this);
 
     this._updateGroupByFrame();
     Common.moduleSetting('network.group-by-frame').addChangeListener(() => this._updateGroupByFrame());
   }
 
   _updateGroupByFrame() {
     var value = Common.moduleSetting('network.group-by-frame').get();
     this._setGrouping(value ? 'Frame' : null);
   }
 
@@ skipping 225 matching lines @@
       return false;
     return true;
   }
 
   /**
    * @param {?string} groupKey
    */
   _setGrouping(groupKey) {
     var groupLookup = groupKey ? this._groupLookups.get(groupKey) || null : null;
     this._activeGroupLookup = groupLookup;
-    if (groupLookup)
-      groupLookup.reset();
     this._invalidateAllItems();
   }
 
   _updateRowHeight() {
     this._rowHeight = Math.floor(this._rawRowHeight * window.devicePixelRatio) / window.devicePixelRatio;
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
    * @return {?Network.NetworkRequestNode}
    */
   nodeForRequest(request) {
-    return this._nodesByRequestId.get(request.requestId());
+    return request[Network.NetworkLogView._networkNodeSymbol] || null;
   }
 
   /**
    * @return {number}
    */
   headerHeight() {
     return this._headerHeight;
   }
 
   /**
    * @param {boolean} recording
    */
   setRecording(recording) {
     this._recording = recording;
     this._updateSummaryBar();
   }
 
   /**
    * @override
    * @param {!SDK.NetworkManager} networkManager
    */
   modelAdded(networkManager) {
-    if (!networkManager.target().parentTarget()) {
-      var resourceTreeModel = networkManager.target().model(SDK.ResourceTreeModel);
-      if (resourceTreeModel) {
-        resourceTreeModel.addEventListener(
-            SDK.ResourceTreeModel.Events.MainFrameNavigated, this._mainFrameNavigated, this);
-        resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.Load, this._loadEventFired, this);
-        resourceTreeModel.addEventListener(
-            SDK.ResourceTreeModel.Events.DOMContentLoaded, this._domContentLoadedEventFired, this);
-      }
+    // TODO(allada) Remove dependency on networkManager and instead use NetworkLog and PageLoad for needed data.
+    if (networkManager.target().parentTarget())
+      return;
+    var resourceTreeModel = networkManager.target().model(SDK.ResourceTreeModel);
+    if (resourceTreeModel) {
+      resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.Load, this._loadEventFired, this);
+      resourceTreeModel.addEventListener(
+          SDK.ResourceTreeModel.Events.DOMContentLoaded, this._domContentLoadedEventFired, this);
     }
-    NetworkLog.networkLog.requestsForManager(networkManager).forEach(this._appendRequest.bind(this));
   }
 
   /**
    * @override
    * @param {!SDK.NetworkManager} networkManager
    */
   modelRemoved(networkManager) {
     if (!networkManager.target().parentTarget()) {
       var resourceTreeModel = networkManager.target().model(SDK.ResourceTreeModel);
       if (resourceTreeModel) {
-        resourceTreeModel.removeEventListener(
-            SDK.ResourceTreeModel.Events.MainFrameNavigated, this._mainFrameNavigated, this);
         resourceTreeModel.removeEventListener(SDK.ResourceTreeModel.Events.Load, this._loadEventFired, this);
         resourceTreeModel.removeEventListener(
             SDK.ResourceTreeModel.Events.DOMContentLoaded, this._domContentLoadedEventFired, this);
       }
     }
   }
 
   /**
    * @param {number} start
    * @param {number} end
@@ skipping 75 matching lines @@
     reloadShortcutNode.textContent = UI.shortcutRegistry.shortcutDescriptorsForAction('main.reload')[0].name;
 
     if (this._recording) {
       var recordingText = hintText.createChild('span');
       recordingText.textContent = Common.UIString('Recording network activity\u2026');
       hintText.createChild('br');
       hintText.appendChild(
           UI.formatLocalized('Perform a request or hit %s to record the reload.', [reloadShortcutNode]));
     } else {
       var recordNode = hintText.createChild('b');
-      recordNode.textContent = UI.shortcutRegistry.shortcutTitleForAction('network.toggle-recording');
+      recordNode.textContent = UI.shortcutRegistry.shortcutTitleForAction('network_log.toggle-recording');
       hintText.appendChild(UI.formatLocalized(
           'Record (%s) or reload (%s) to display network activity.', [recordNode, reloadShortcutNode]));
     }
   }
 
   _hideRecordingHint() {
     if (this._recordingHint)
       this._recordingHint.remove();
     delete this._recordingHint;
   }
@@ skipping 59 matching lines @@
 
   /**
    * @param {!Event} event
    */
   _dataGridMouseDown(event) {
     if (!this._dataGrid.selectedNode && event.button)
       event.consume();
   }
 
   _updateSummaryBar() {
-    var requestsNumber = this._nodesByRequestId.size;
-
-    if (!requestsNumber) {
-      this._showRecordingHint();
-      return;
-    }
     this._hideRecordingHint();
 
     var transferSize = 0;
-    var selectedRequestsNumber = 0;
+    var selectedNodeNumber = 0;
     var selectedTransferSize = 0;
     var baseTime = -1;
     var maxTime = -1;
-    var nodes = this._nodesByRequestId.valuesArray();
-    for (var i = 0; i < nodes.length; ++i) {
-      var request = nodes[i].request();
+
+    var nodeCount = 0;
+    for (var request of NetworkLog.networkLog.requests()) {
+      var node = request[Network.NetworkLogView._networkNodeSymbol];
+      if (!node)
+        continue;
+      nodeCount++;
       var requestTransferSize = request.transferSize;
       transferSize += requestTransferSize;
-      if (!nodes[i][Network.NetworkLogView._isFilteredOutSymbol]) {
-        selectedRequestsNumber++;
+      if (!node[Network.NetworkLogView._isFilteredOutSymbol]) {
+        selectedNodeNumber++;
         selectedTransferSize += requestTransferSize;
       }
       if (request.url() === request.networkManager().target().inspectedURL() &&
           request.resourceType() === Common.resourceTypes.Document)
         baseTime = request.startTime;
       if (request.endTime > maxTime)
         maxTime = request.endTime;
     }
 
+    if (!nodeCount) {
+      this._showRecordingHint();
+      return;
+    }
+
     var summaryBar = this._summaryBarElement;
     summaryBar.removeChildren();
     var separator = '\u2002\u2758\u2002';
     var text = '';
     /**
      * @param {string} chunk
      * @return {!Element}
      */
     function appendChunk(chunk) {
       var span = summaryBar.createChild('span');
       span.textContent = chunk;
       text += chunk;
       return span;
     }
 
-    if (selectedRequestsNumber !== requestsNumber) {
-      appendChunk(Common.UIString('%d / %d requests', selectedRequestsNumber, requestsNumber));
+    if (selectedNodeNumber !== nodeCount) {
+      appendChunk(Common.UIString('%d / %d requests', selectedNodeNumber, nodeCount));
       appendChunk(separator);
       appendChunk(Common.UIString(
           '%s / %s transferred', Number.bytesToString(selectedTransferSize), Number.bytesToString(transferSize)));
     } else {
-      appendChunk(Common.UIString('%d requests', requestsNumber));
+      appendChunk(Common.UIString('%d requests', nodeCount));
       appendChunk(separator);
       appendChunk(Common.UIString('%s transferred', Number.bytesToString(transferSize)));
     }
     if (baseTime !== -1 && maxTime !== -1) {
       appendChunk(separator);
       appendChunk(Common.UIString('Finish: %s', Number.secondsToString(maxTime - baseTime)));
       if (this._mainRequestDOMContentLoadedTime !== -1 && this._mainRequestDOMContentLoadedTime > baseTime) {
         appendChunk(separator);
         var domContentLoadedText = Common.UIString(
             'DOMContentLoaded: %s', Number.secondsToString(this._mainRequestDOMContentLoadedTime - baseTime));
@@ skipping 38 matching lines @@
 
   _refreshIfNeeded() {
     if (this._needsRefresh)
       this._refresh();
   }
 
   /**
    * @param {boolean=} deferUpdate
    */
   _invalidateAllItems(deferUpdate) {
-    var requestIds = this._nodesByRequestId.keysArray();
-    for (var i = 0; i < requestIds.length; ++i)
-      this._staleRequestIds[requestIds[i]] = true;
+    this._staleRequests = new Set(NetworkLog.networkLog.requests());
     if (deferUpdate)
       this.scheduleRefresh();
     else
       this._refresh();
   }
 
   /**
    * @return {!Network.NetworkTimeCalculator}
    */
   timeCalculator() {
@@ skipping 100 matching lines @@
 
     this._timeCalculator.updateBoundariesForEventTime(this._mainRequestLoadTime);
     this._durationCalculator.updateBoundariesForEventTime(this._mainRequestLoadTime);
     this._timeCalculator.updateBoundariesForEventTime(this._mainRequestDOMContentLoadedTime);
     this._durationCalculator.updateBoundariesForEventTime(this._mainRequestDOMContentLoadedTime);
 
     /** @type {!Map<!Network.NetworkNode, !Network.NetworkNode>} */
     var nodesToInsert = new Map();
     /** @type {!Array<!Network.NetworkNode>} */
     var nodesToRefresh = [];
-    for (var requestId in this._staleRequestIds) {
-      var node = this._nodesByRequestId.get(requestId);
+
+    /** @type {!Set<!Network.NetworkRequestNode>} */
+    var staleNodes = new Set();
+
+    for (var node of this._nodesToRemove) {
+      if (node.parent)
+        node.parent.removeChild(node);
+    }
+
+    this._nodesToRemove.clear();
+
+    // While creating nodes it may add more entries into _staleRequests because redirect request nodes update the parent
+    // node so we loop until we have no more stale requests.
+    while (this._staleRequests.size) {
+      var request = this._staleRequests.firstValue();
+      this._staleRequests.delete(request);
+      var node = request[Network.NetworkLogView._networkNodeSymbol];
       if (!node)
-        continue;
+        node = this._createNodeForRequest(request);
+      staleNodes.add(node);
+    }
+
+    for (var node of staleNodes) {
       var isFilteredOut = !this._applyFilter(node);
       if (isFilteredOut && node === this._hoveredNode)
         this._setHoveredNode(null);
 
       if (!isFilteredOut)
         nodesToRefresh.push(node);
       var request = node.request();
       this._timeCalculator.updateBoundaries(request);
       this._durationCalculator.updateBoundaries(request);
       var newParent = this._parentNodeForInsert(node);
@@ skipping 28 matching lines @@
         node[Network.NetworkLogView._isMatchingSearchQuerySymbol] = this._matchRequest(request);
       parent.appendChild(node);
     }
 
     for (var node of nodesToRefresh)
       node.refresh();
 
     this._highlightNthMatchedRequestForSearch(
         this._updateMatchCountAndFindMatchIndex(this._currentMatchedRequestNode), false);
 
-    this._staleRequestIds = {};
     this._updateSummaryBar();
 
     if (nodesToInsert.size)
       this._columns.sortByCurrentColumn();
 
     this._dataGrid.updateInstantly();
+    this._didRefreshForTest();
+  }
+
+  _didRefreshForTest() {
   }
 
   /**
    * @param {!Network.NetworkRequestNode} node
    * @return {?Network.NetworkNode}
    */
   _parentNodeForInsert(node) {
     if (!this._activeGroupLookup)
       return this._dataGrid.rootNode();
 
     var groupNode = this._activeGroupLookup.groupNodeForRequest(node.request());
     if (!groupNode)
       return this._dataGrid.rootNode();
     return groupNode;
   }
 
-  reset() {
+  _reset() {
     this._requestWithHighlightedInitiators = null;
     this.dispatchEventToListeners(Network.NetworkLogView.Events.RequestSelected, null);
 
     this._clearSearchMatchedList();
 
     this._setHoveredNode(null);
     this._columns.reset();
 
     this._timeFilter = null;
     this._calculator.reset();
 
     this._timeCalculator.setWindow(null);
     this.linkifier.reset();
     this.badgePool.reset();
 
-    if (this._activeGroupLookup)
-      this._activeGroupLookup.reset();
-    this._nodesByRequestId.clear();
-    this._staleRequestIds = {};
+    this._staleRequests.clear();
     this._resetSuggestionBuilder();
 
     this._mainRequestLoadTime = -1;
     this._mainRequestDOMContentLoadedTime = -1;
 
     this._dataGrid.rootNode().removeChildren();
     this._updateSummaryBar();
     this._dataGrid.setStickToBottom(true);
   }
 
   /**
    * @param {string} filterString
    */
   setTextFilterValue(filterString) {
     this._textFilterUI.setValue(filterString);
     this._textFilterUI.setRegexChecked(false);
     this._dataURLFilterUI.setChecked(false);
     this._resourceCategoryFilterUI.reset();
   }
 
   /**
+   * @param {!SDK.NetworkRequest} request
+   */
+  _createNodeForRequest(request) {
+    var node = new Network.NetworkRequestNode(this, request);
+    request[Network.NetworkLogView._networkNodeSymbol] = node;
+    node[Network.NetworkLogView._isFilteredOutSymbol] = true;
+    node[Network.NetworkLogView._isMatchingSearchQuerySymbol] = false;
+
+    if (request.redirects)
+      request.redirects.forEach(this._refreshRequest.bind(this));
+    return node;
+  }
+
+  /**
    * @param {!Common.Event} event
    */
-  _onRequestStarted(event) {
-    if (!this._recording)
-      return;
-    var request = /** @type {!SDK.NetworkRequest} */ (event.data);
-    this._appendRequest(request);
+  _onRequestsRemoved(event) {
+    var requests = /** @type {!Set<!SDK.NetworkRequest>} */ (event.data);
+    var rootNode = this._dataGrid.rootNode();
+    for (var request of requests) {
+      var node = request[Network.NetworkLogView._networkNodeSymbol];
+      while (node && node.parent) {
+        var parent = node.parent;
+        this._nodesToRemove.add(node);
+        if (parent === rootNode || !parent.children.every(child => this._nodesToRemove.has(child)))
+          break;
+        node = parent;
+      }
+      this._staleRequests.delete(request);
+      delete request[Network.NetworkLogView._networkNodeSymbol];
+    }
   }
 
   /**
-   * @param {!SDK.NetworkRequest} request
-   */
-  _appendRequest(request) {
-    var node = new Network.NetworkRequestNode(this, request);
-    node[Network.NetworkLogView._isFilteredOutSymbol] = true;
-    node[Network.NetworkLogView._isMatchingSearchQuerySymbol] = false;
-
-    // In case of redirect request id is reassigned to a redirected
-    // request and we need to update _nodesByRequestId and search results.
-    var originalRequestNode = this._nodesByRequestId.get(request.requestId());
-    if (originalRequestNode)
-      this._nodesByRequestId.set(originalRequestNode.request().requestId(), originalRequestNode);
-    this._nodesByRequestId.set(request.requestId(), node);
-
-    // Pull all the redirects of the main request upon commit load.
-    if (request.redirects) {
-      for (var i = 0; i < request.redirects.length; ++i)
-        this._refreshRequest(request.redirects[i]);
-    }
-
-    this._refreshRequest(request);
-  }
-
-  /**
    * @param {!Common.Event} event
    */
   _onRequestUpdated(event) {
     var request = /** @type {!SDK.NetworkRequest} */ (event.data);
     this._refreshRequest(request);
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
    */
   _refreshRequest(request) {
-    if (!this._nodesByRequestId.get(request.requestId()))
-      return;
-
     Network.NetworkLogView._subdomains(request.domain)
         .forEach(
             this._suggestionBuilder.addItem.bind(this._suggestionBuilder, Network.NetworkLogView.FilterType.Domain));
     this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.Method, request.requestMethod);
     this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.MimeType, request.mimeType);
     this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.Scheme, '' + request.scheme);
     this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.StatusCode, '' + request.statusCode);
 
     var priority = request.initialPriority();
     if (priority) {
@@ skipping 21 matching lines @@
     for (var i = 0, l = responseHeaders.length; i < l; ++i)
       this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.HasResponseHeader, responseHeaders[i].name);
     var cookies = request.responseCookies;
     for (var i = 0, l = cookies ? cookies.length : 0; i < l; ++i) {
       var cookie = cookies[i];
       this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.SetCookieDomain, cookie.domain());
       this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.SetCookieName, cookie.name());
       this._suggestionBuilder.addItem(Network.NetworkLogView.FilterType.SetCookieValue, cookie.value());
     }
 
-    this._staleRequestIds[request.requestId()] = true;
-    this.dispatchEventToListeners(Network.NetworkLogView.Events.UpdateRequest, request);
+    this._staleRequests.add(request);
     this.scheduleRefresh();
   }
 
   /**
-   * @param {!Common.Event} event
-   */
-  _mainFrameNavigated(event) {
-    if (!this._recording)
-      return;
-
-    var frame = /** @type {!SDK.ResourceTreeFrame} */ (event.data);
-    var loaderId = frame.loaderId;
-
-    // Pick provisional load requests.
-    var requestsToPick = [];
-    var networkManager = frame.resourceTreeModel().target().model(SDK.NetworkManager);
-    var requests = networkManager ? NetworkLog.networkLog.requestsForManager(networkManager) : [];
-    for (var i = 0; i < requests.length; ++i) {
-      var request = requests[i];
-      if (request.loaderId === loaderId)
-        requestsToPick.push(request);
-    }
-
-    if (!Common.moduleSetting('network.preserve-log').get()) {
-      this.reset();
-      for (var i = 0; i < requestsToPick.length; ++i)
-        this._appendRequest(requestsToPick[i]);
-    }
-    for (var i = 0; i < requestsToPick.length; ++i) {
-      var request = requestsToPick[i];
-      var node = this._nodesByRequestId.get(request.requestId());
-      if (node) {
-        node.markAsNavigationRequest();
-        break;
-      }
-    }
-  }
-
-  /**
    * @return {number}
    */
   rowHeight() {
     return this._rowHeight;
   }
 
   /**
    * @param {boolean} gridMode
    */
   switchViewMode(gridMode) {
@@ skipping 91 matching lines @@
        */
       function removeBlockedURL(url) {
         patterns = patterns.filter(pattern => pattern.url !== url);
         manager.setBlockedPatterns(patterns);
         UI.viewManager.showView('network.blocked-urls');
       }
     }
   }
 
   _harRequests() {
-    var requests = this._nodesByRequestId.valuesArray().map(function(node) {
-      return node.request();
-    });
-    var httpRequests = requests.filter(Network.NetworkLogView.HTTPRequestsFilter);
+    var httpRequests = NetworkLog.networkLog.requests().filter(Network.NetworkLogView.HTTPRequestsFilter);
     return httpRequests.filter(Network.NetworkLogView.FinishedRequestsFilter);
   }
 
   _copyAll() {
     var harArchive = {log: (new NetworkLog.HARLog(this._harRequests())).build()};
     InspectorFrontendHost.copyText(JSON.stringify(harArchive, null, 2));
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
@@ skipping 29 matching lines @@
    * @param {string} platform
    */
   _copyCurlCommand(request, platform) {
     InspectorFrontendHost.copyText(this._generateCurlCommand(request, platform));
   }
 
   /**
    * @param {string} platform
    */
   _copyAllCurlCommand(platform) {
-    var requests = this._nodesByRequestId.valuesArray().map(node => node.request());
+    var requests = NetworkLog.networkLog.requests();
     var commands = [];
     for (var request of requests)
       commands.push(this._generateCurlCommand(request, platform));
     if (platform === 'win')
       InspectorFrontendHost.copyText(commands.join(' &\r\n'));
     else
       InspectorFrontendHost.copyText(commands.join(' ;\n'));
   }
 
   _exportAll() {
@@ skipping 347 matching lines @@
     this._clearSearchMatchedList();
     this.dispatchEventToListeners(Network.NetworkLogView.Events.SearchCountUpdated, 0);
   }
 
   /**
    * @param {!SDK.NetworkRequest} request
    */
   revealAndHighlightRequest(request) {
     this.removeAllNodeHighlights();
 
-    var node = this._nodesByRequestId.get(request.requestId());
+    var node = request[Network.NetworkLogView._networkNodeSymbol];
     if (node) {
       node.reveal();
       this._highlightNode(node);
     }
   }
 
   removeAllNodeHighlights() {
     if (this._highlightedNode) {
       this._highlightedNode.element().classList.remove('highlighted-row');
       delete this._highlightedNode;
@@ skipping 130 matching lines @@
     command.push('--compressed');
 
     if (request.securityState() === Protocol.Security.SecurityState.Insecure)
       command.push('--insecure');
     return command.join(' ');
   }
 };
 
 Network.NetworkLogView._isFilteredOutSymbol = Symbol('isFilteredOut');
 Network.NetworkLogView._isMatchingSearchQuerySymbol = Symbol('isMatchingSearchQuery');
+Network.NetworkLogView._networkNodeSymbol = Symbol('NetworkNode');
 
 Network.NetworkLogView.HTTPSchemas = {
   'http': true,
   'https': true,
   'ws': true,
   'wss': true
 };
 
 /** @enum {symbol} */
 Network.NetworkLogView.Events = {
   RequestSelected: Symbol('RequestSelected'),
   SearchCountUpdated: Symbol('SearchCountUpdated'),
-  SearchIndexUpdated: Symbol('SearchIndexUpdated'),
-  UpdateRequest: Symbol('UpdateRequest')
+  SearchIndexUpdated: Symbol('SearchIndexUpdated')
 };
 
 /** @enum {string} */
 Network.NetworkLogView.FilterType = {
   Domain: 'domain',
   HasResponseHeader: 'has-response-header',
   Is: 'is',
   LargerThan: 'larger-than',
   Method: 'method',
   MimeType: 'mime-type',
@@ skipping 30 matching lines @@
 /**
  * @interface
  */
 Network.GroupLookupInterface = function() {};
 
 Network.GroupLookupInterface.prototype = {
   /**
    * @param {!SDK.NetworkRequest} request
    * @return {?Network.NetworkGroupNode}
    */
-  groupNodeForRequest: function(request) {},
-
-  reset: function() {}
+  groupNodeForRequest: function(request) {}
 };