blob: de8f3ec27ca71a65b369bef61d567d4ff32cb3cf [file] [log] [blame]
/*
* Copyright (C) 2013, 2015 Apple 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
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 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.
*/
WI.NavigationSidebarPanel = class NavigationSidebarPanel extends WI.SidebarPanel
{
constructor(identifier, displayName, shouldAutoPruneStaleTopLevelResourceTreeElements, wantsTopOverflowShadow)
{
super(identifier, displayName);
this.element.classList.add("navigation");
this._updateContentOverflowShadowVisibilityDebouncer = new Debouncer(() => {
this._updateContentOverflowShadowVisibility();
});
this._boundUpdateContentOverflowShadowVisibilitySoon = (event) => {
this._updateContentOverflowShadowVisibilityDebouncer.delayForTime(0);
};
this.contentView.element.addEventListener("scroll", this._boundUpdateContentOverflowShadowVisibilitySoon);
this._contentTreeOutlineGroup = new WI.TreeOutlineGroup;
this._contentTreeOutline = this.createContentTreeOutline();
this._filterBar = new WI.FilterBar;
this._filterBar.addEventListener(WI.FilterBar.Event.FilterDidChange, this._filterDidChange, this);
this.element.appendChild(this._filterBar.element);
this._bottomOverflowShadowElement = document.createElement("div");
this._bottomOverflowShadowElement.className = WI.NavigationSidebarPanel.OverflowShadowElementStyleClassName;
this.element.appendChild(this._bottomOverflowShadowElement);
if (wantsTopOverflowShadow) {
this._topOverflowShadowElement = this.element.appendChild(document.createElement("div"));
this._topOverflowShadowElement.classList.add(WI.NavigationSidebarPanel.OverflowShadowElementStyleClassName, "top");
}
window.addEventListener("resize", this._boundUpdateContentOverflowShadowVisibilitySoon);
this._filtersSetting = new WI.Setting(identifier + "-navigation-sidebar-filters", {});
this._filterBar.filters = this._filtersSetting.value;
this._emptyContentPlaceholderElements = new Map;
this._emptyFilterResults = new Set;
this._shouldAutoPruneStaleTopLevelResourceTreeElements = shouldAutoPruneStaleTopLevelResourceTreeElements || false;
if (this._shouldAutoPruneStaleTopLevelResourceTreeElements) {
WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._checkForStaleResources, this);
WI.Frame.addEventListener(WI.Frame.Event.ChildFrameWasRemoved, this._checkForStaleResources, this);
WI.Frame.addEventListener(WI.Frame.Event.ResourceWasRemoved, this._checkForStaleResources, this);
}
this._pendingViewStateCookie = null;
this._restoringState = false;
}
// Public
get filterBar() { return this._filterBar; }
get hasActiveFilters() { return this._filterBar.hasActiveFilters(); }
closed()
{
window.removeEventListener("resize", this._boundUpdateContentOverflowShadowVisibilitySoon);
WI.Frame.removeEventListener(null, null, this);
}
get contentBrowser()
{
return this._contentBrowser;
}
set contentBrowser(contentBrowser)
{
this._contentBrowser = contentBrowser || null;
}
get contentTreeOutline()
{
return this._contentTreeOutline;
}
get contentTreeOutlines()
{
return Array.from(this._contentTreeOutlineGroup);
}
get currentRepresentedObject()
{
if (!this._contentBrowser)
return null;
return this._contentBrowser.currentRepresentedObjects[0] || null;
}
get restoringState()
{
return this._restoringState;
}
cancelRestoringState()
{
this._pendingViewStateCookie = null;
if (!this._finalAttemptToRestoreViewStateTimeout)
return;
clearTimeout(this._finalAttemptToRestoreViewStateTimeout);
this._finalAttemptToRestoreViewStateTimeout = undefined;
}
createContentTreeOutline({ignoreCookieRestoration, suppressFiltering} = {})
{
let contentTreeOutline = new WI.TreeOutline;
contentTreeOutline.allowsRepeatSelection = true;
contentTreeOutline.element.classList.add(WI.NavigationSidebarPanel.ContentTreeOutlineElementStyleClassName);
this._contentTreeOutlineGroup.add(contentTreeOutline);
this.contentView.element.appendChild(contentTreeOutline.element);
if (!suppressFiltering) {
contentTreeOutline.addEventListener(WI.TreeOutline.Event.ElementAdded, this._treeElementAddedOrChanged, this);
contentTreeOutline.addEventListener(WI.TreeOutline.Event.ElementDidChange, this._treeElementAddedOrChanged, this);
contentTreeOutline.addEventListener(WI.TreeOutline.Event.ElementDisclosureDidChanged, this._treeElementDisclosureDidChange, this);
contentTreeOutline.addEventListener(WI.TreeOutline.Event.ElementRemoved, this._handleTreeElementRemoved, this);
}
contentTreeOutline[WI.NavigationSidebarPanel.IgnoreCookieRestoration] = ignoreCookieRestoration;
contentTreeOutline[WI.NavigationSidebarPanel.SuppressFilteringSymbol] = suppressFiltering;
return contentTreeOutline;
}
suppressFilteringOnTreeElements(treeElements)
{
console.assert(Array.isArray(treeElements), "TreeElements should be an array.");
for (let treeElement of treeElements)
treeElement[WI.NavigationSidebarPanel.SuppressFilteringSymbol] = true;
this.updateFilter();
}
treeElementForRepresentedObject(representedObject)
{
let treeElement = null;
for (let treeOutline of this.contentTreeOutlines) {
treeElement = treeOutline.getCachedTreeElement(representedObject);
if (treeElement)
break;
}
return treeElement;
}
showDefaultContentView()
{
// Implemented by subclasses if needed to show a content view when no existing tree element is selected.
}
showDefaultContentViewForTreeElement(treeElement)
{
console.assert(treeElement);
console.assert(treeElement.representedObject);
if (!treeElement || !treeElement.representedObject)
return false;
// FIXME: <https://webkit.org/b/153634> Web Inspector: some background tabs think they are the foreground tab and do unnecessary work
// Do not steal a content view if we are not the active tab/sidebar.
if (!this.selected) {
let contentView = this.contentBrowser.contentViewForRepresentedObject(treeElement.representedObject);
if (contentView && contentView.parentContainer && contentView.parentContainer !== this.contentBrowser.contentViewContainer)
return false;
// contentView.parentContainer may be null. Check for selected tab, too.
let selectedTabContentView = WI.tabBrowser.selectedTabContentView;
if (selectedTabContentView && selectedTabContentView.contentBrowser !== this.contentBrowser)
return false;
}
let contentView = this.contentBrowser.showContentViewForRepresentedObject(treeElement.representedObject);
if (!contentView)
return false;
treeElement.revealAndSelect(true, false, true);
return true;
}
canShowRepresentedObject(representedObject)
{
let selectedTabContentView = WI.tabBrowser.selectedTabContentView;
console.assert(selectedTabContentView instanceof WI.TabContentView, "Missing TabContentView for NavigationSidebarPanel.");
return selectedTabContentView && selectedTabContentView.canShowRepresentedObject(representedObject);
}
saveStateToCookie(cookie)
{
console.assert(cookie);
if (!this._contentBrowser)
return;
let representedObject = this.currentRepresentedObject;
if (!representedObject)
return;
cookie[WI.TypeIdentifierCookieKey] = representedObject.constructor.TypeIdentifier;
if (representedObject.saveIdentityToCookie) {
representedObject.saveIdentityToCookie(cookie);
return;
}
console.error("NavigationSidebarPanel representedObject is missing a saveIdentityToCookie implementation.", representedObject);
}
// This can be supplemented by subclasses that admit a simpler strategy for static tree elements.
restoreStateFromCookie(cookie, relaxedMatchDelay)
{
this._pendingViewStateCookie = cookie;
this._restoringState = true;
// Check if any existing tree elements in any outline match the cookie.
this._checkOutlinesForPendingViewStateCookie();
if (this._finalAttemptToRestoreViewStateTimeout)
clearTimeout(this._finalAttemptToRestoreViewStateTimeout);
if (relaxedMatchDelay === 0)
return;
function finalAttemptToRestoreViewStateFromCookie()
{
this._finalAttemptToRestoreViewStateTimeout = undefined;
this._checkOutlinesForPendingViewStateCookie(true);
this._pendingViewStateCookie = null;
this._restoringState = false;
}
// If the specific tree element wasn't found, we may need to wait for the resources
// to be registered. We try one last time (match type only) after an arbitrary amount of timeout.
this._finalAttemptToRestoreViewStateTimeout = setTimeout(finalAttemptToRestoreViewStateFromCookie.bind(this), relaxedMatchDelay);
}
showEmptyContentPlaceholder(message, treeOutline)
{
console.assert(message);
treeOutline = treeOutline || this._contentTreeOutline;
let emptyContentPlaceholderElement = this._emptyContentPlaceholderElements.get(treeOutline);
if (emptyContentPlaceholderElement)
emptyContentPlaceholderElement.remove();
emptyContentPlaceholderElement = message instanceof Node ? message : WI.createMessageTextView(message);
this._emptyContentPlaceholderElements.set(treeOutline, emptyContentPlaceholderElement);
let emptyContentPlaceholderParentElement = treeOutline.element.parentNode;
emptyContentPlaceholderParentElement.appendChild(emptyContentPlaceholderElement);
this._updateContentOverflowShadowVisibilityDebouncer.force();
return emptyContentPlaceholderElement;
}
hideEmptyContentPlaceholder(treeOutline)
{
treeOutline = treeOutline || this._contentTreeOutline;
let emptyContentPlaceholderElement = this._emptyContentPlaceholderElements.get(treeOutline);
if (!emptyContentPlaceholderElement || !emptyContentPlaceholderElement.parentNode)
return;
emptyContentPlaceholderElement.remove();
this._emptyContentPlaceholderElements.delete(treeOutline);
this._updateContentOverflowShadowVisibilityDebouncer.force();
}
updateEmptyContentPlaceholder(message, treeOutline)
{
treeOutline = treeOutline || this._contentTreeOutline;
if (!treeOutline.children.length) {
// No tree elements, so no results.
this.showEmptyContentPlaceholder(message, treeOutline);
} else if (!this._emptyFilterResults.has(treeOutline)) {
// There are tree elements, and not all of them are hidden by the filter.
this.hideEmptyContentPlaceholder(treeOutline);
}
}
updateFilter()
{
let filters = this._filterBar.filters;
this._textFilterRegex = filters.text ? WI.SearchUtilities.filterRegExpForString(filters.text, WI.SearchUtilities.defaultSettings) : null;
this._filtersSetting.value = filters;
this._filterFunctions = filters.functions;
this._filterBar.invalid = filters.text && !this._textFilterRegex;
// Don't populate if we don't have any active filters.
// We only need to populate when a filter needs to reveal.
let dontPopulate = !this._filterBar.hasActiveFilters() && !this.shouldFilterPopulate();
// Update all trees that allow filtering.
for (let treeOutline of this.contentTreeOutlines) {
if (treeOutline.hidden || treeOutline[WI.NavigationSidebarPanel.SuppressFilteringSymbol])
continue;
let currentTreeElement = treeOutline.children[0];
while (currentTreeElement && !currentTreeElement.root) {
if (!currentTreeElement[WI.NavigationSidebarPanel.SuppressFilteringSymbol]) {
const currentTreeElementWasHidden = currentTreeElement.hidden;
this.applyFiltersToTreeElement(currentTreeElement);
if (currentTreeElementWasHidden !== currentTreeElement.hidden)
this._treeElementWasFiltered(currentTreeElement);
}
currentTreeElement = currentTreeElement.traverseNextTreeElement(false, null, dontPopulate);
}
this._checkForEmptyFilterResults(treeOutline);
}
this._updateContentOverflowShadowVisibilityDebouncer.force();
}
resetFilter()
{
this._filterBar.clear();
}
shouldFilterPopulate()
{
// Overridden by subclasses if needed.
return this.hasCustomFilters();
}
hasCustomFilters()
{
// Implemented by subclasses if needed.
return false;
}
matchTreeElementAgainstCustomFilters(treeElement)
{
// Implemented by subclasses if needed.
return true;
}
matchTreeElementAgainstFilterFunctions(treeElement)
{
if (!this._filterFunctions || !this._filterFunctions.length)
return true;
for (var filterFunction of this._filterFunctions) {
if (filterFunction(treeElement))
return true;
}
return false;
}
applyFiltersToTreeElement(treeElement)
{
if (!this._filterBar.hasActiveFilters() && !this.hasCustomFilters()) {
// No filters, so make everything visible.
treeElement.hidden = false;
// If this tree element was expanded during filtering, collapse it again.
if (treeElement.expanded && treeElement[WI.NavigationSidebarPanel.WasExpandedDuringFilteringSymbol]) {
treeElement[WI.NavigationSidebarPanel.WasExpandedDuringFilteringSymbol] = false;
treeElement.collapse();
}
return;
}
var filterableData = treeElement.filterableData || {};
var flags = {expandTreeElement: false};
var filterRegex = this._textFilterRegex;
function matchTextFilter(inputs)
{
if (!inputs || !filterRegex)
return true;
console.assert(inputs instanceof Array, "filterableData.text should be an array of text inputs");
// Loop over all the inputs and try to match them.
for (var input of inputs) {
if (!input)
continue;
if (filterRegex.test(input)) {
flags.expandTreeElement = true;
return true;
}
}
// No inputs matched.
return false;
}
function makeVisible()
{
// Make this element visible.
treeElement.hidden = false;
// Make the ancestors visible and expand them.
var currentAncestor = treeElement.parent;
while (currentAncestor && !currentAncestor.root) {
currentAncestor.hidden = false;
// Only expand if the built-in filters matched, not custom filters.
if (flags.expandTreeElement && !currentAncestor.expanded) {
currentAncestor.__wasExpandedDuringFiltering = true;
currentAncestor.expand();
}
currentAncestor = currentAncestor.parent;
}
}
let suppressFiltering = treeElement[WI.NavigationSidebarPanel.SuppressFilteringSymbol];
if (suppressFiltering || (matchTextFilter(filterableData.text) && this.matchTreeElementAgainstFilterFunctions(treeElement, flags) && this.matchTreeElementAgainstCustomFilters(treeElement, flags))) {
// Make this element visible since it matches.
makeVisible();
// If this tree element didn't match a built-in filter and was expanded earlier during filtering, collapse it again.
if (!flags.expandTreeElement && treeElement.expanded && treeElement[WI.NavigationSidebarPanel.WasExpandedDuringFilteringSymbol]) {
treeElement[WI.NavigationSidebarPanel.WasExpandedDuringFilteringSymbol] = false;
treeElement.collapse();
}
return;
}
// Make this element invisible since it does not match.
treeElement.hidden = true;
}
shown()
{
super.shown();
this._updateContentOverflowShadowVisibilityDebouncer.force();
}
// Protected
pruneStaleResourceTreeElements()
{
if (this._checkForStaleResourcesTimeoutIdentifier) {
clearTimeout(this._checkForStaleResourcesTimeoutIdentifier);
this._checkForStaleResourcesTimeoutIdentifier = undefined;
}
for (let contentTreeOutline of this.contentTreeOutlines) {
// Check all the ResourceTreeElements at the top level to make sure their Resource still has a parentFrame in the frame hierarchy.
// If the parentFrame is no longer in the frame hierarchy we know it was removed due to a navigation or some other page change and
// we should remove the issues for that resource.
for (let i = contentTreeOutline.children.length - 1; i >= 0; --i) {
let treeElement = contentTreeOutline.children[i];
if (!(treeElement instanceof WI.ResourceTreeElement))
continue;
// Local Overrides are never stale resources.
let resource = treeElement.resource;
if (resource.isLocalResourceOverride)
continue;
if (!resource.parentFrame || resource.parentFrame.isDetached())
contentTreeOutline.removeChildAtIndex(i, true, true);
}
}
}
// Private
_updateContentOverflowShadowVisibility()
{
if (!this.visible)
return;
let scrollHeight = this.contentView.element.scrollHeight;
let offsetHeight = this.contentView.element.offsetHeight;
if (scrollHeight < offsetHeight) {
if (this._topOverflowShadowElement)
this._topOverflowShadowElement.style.opacity = 0;
this._bottomOverflowShadowElement.style.opacity = 0;
return;
}
let edgeThreshold = 1;
let scrollTop = this.contentView.element.scrollTop;
let topCoverage = Math.min(scrollTop, edgeThreshold);
let bottomCoverage = Math.max(0, (offsetHeight + scrollTop) - (scrollHeight - edgeThreshold));
if (this._topOverflowShadowElement)
this._topOverflowShadowElement.style.opacity = (topCoverage / edgeThreshold).toFixed(1);
this._bottomOverflowShadowElement.style.opacity = (1 - (bottomCoverage / edgeThreshold)).toFixed(1);
}
_checkForEmptyFilterResults(treeOutline)
{
if (treeOutline[WI.NavigationSidebarPanel.SuppressFilteringSymbol])
return;
// No tree elements, so don't touch the empty content placeholder.
if (!treeOutline.children.length)
return;
// Iterate over all the top level tree elements. If any filterable elements are visible, return early.
let filterableTreeElementFound = false;
let unfilteredTreeElementFound = false;
let currentTreeElement = treeOutline.children[0];
while (currentTreeElement) {
let suppressFilteringForTreeElement = currentTreeElement[WI.NavigationSidebarPanel.SuppressFilteringSymbol];
if (!suppressFilteringForTreeElement) {
filterableTreeElementFound = true;
if (!currentTreeElement.hidden) {
unfilteredTreeElementFound = true;
break;
}
}
currentTreeElement = currentTreeElement.nextSibling;
}
if (unfilteredTreeElementFound || !filterableTreeElementFound) {
this.hideEmptyContentPlaceholder(treeOutline);
this._emptyFilterResults.delete(treeOutline);
return;
}
let message = WI.createMessageTextView(WI.UIString("No Filter Results"));
let buttonElement = message.appendChild(document.createElement("button"));
buttonElement.textContent = WI.UIString("Clear Filters");
buttonElement.addEventListener("click", () => {
this.resetFilter();
});
// All top level tree elements are hidden, so filtering hid everything. Show a message.
this.showEmptyContentPlaceholder(message, treeOutline);
this._emptyFilterResults.add(treeOutline);
}
_filterDidChange()
{
this.updateFilter();
}
_treeElementAddedOrChanged(event)
{
// Don't populate if we don't have any active filters.
// We only need to populate when a filter needs to reveal.
var dontPopulate = !this._filterBar.hasActiveFilters() && !this.shouldFilterPopulate();
// Apply the filters to the tree element and its descendants.
let treeElement = event.data.element;
let currentTreeElement = treeElement;
while (currentTreeElement && !currentTreeElement.root) {
if (!currentTreeElement[WI.NavigationSidebarPanel.SuppressFilteringSymbol]) {
const currentTreeElementWasHidden = currentTreeElement.hidden;
this.applyFiltersToTreeElement(currentTreeElement);
if (currentTreeElementWasHidden !== currentTreeElement.hidden)
this._treeElementWasFiltered(currentTreeElement);
}
currentTreeElement = currentTreeElement.traverseNextTreeElement(false, treeElement, dontPopulate);
}
this._checkForEmptyFilterResults(event.target);
if (this.visible)
this._updateContentOverflowShadowVisibilityDebouncer.delayForTime(0);
if (this.selected && !treeElement.treeOutline[WI.NavigationSidebarPanel.IgnoreCookieRestoration])
this._checkElementsForPendingViewStateCookie([treeElement]);
}
_treeElementDisclosureDidChange(event)
{
this._updateContentOverflowShadowVisibilityDebouncer.delayForTime(0);
}
_handleTreeElementRemoved(event)
{
this._checkForEmptyFilterResults(event.target);
if (this.visible)
this._updateContentOverflowShadowVisibilityDebouncer.delayForTime(0);
}
_checkForStaleResourcesIfNeeded()
{
if (!this._checkForStaleResourcesTimeoutIdentifier || !this._shouldAutoPruneStaleTopLevelResourceTreeElements)
return;
this.pruneStaleResourceTreeElements();
}
_checkForStaleResources(event)
{
console.assert(this._shouldAutoPruneStaleTopLevelResourceTreeElements);
if (this._checkForStaleResourcesTimeoutIdentifier)
return;
// Check on a delay to coalesce multiple calls to _checkForStaleResources.
this._checkForStaleResourcesTimeoutIdentifier = setTimeout(this.pruneStaleResourceTreeElements.bind(this));
}
_isTreeElementWithoutRepresentedObject(treeElement)
{
return treeElement instanceof WI.FolderTreeElement
|| treeElement instanceof WI.DatabaseHostTreeElement
|| treeElement instanceof WI.IndexedDatabaseHostTreeElement
|| treeElement instanceof WI.ApplicationCacheManifestTreeElement
|| treeElement instanceof WI.ThreadTreeElement
|| treeElement instanceof WI.IdleTreeElement
|| treeElement instanceof WI.DOMBreakpointTreeElement
|| treeElement instanceof WI.EventBreakpointTreeElement
|| treeElement instanceof WI.URLBreakpointTreeElement
|| treeElement instanceof WI.CSSStyleSheetTreeElement
|| typeof treeElement.representedObject === "string"
|| treeElement.representedObject instanceof String;
}
_checkOutlinesForPendingViewStateCookie(matchTypeOnly)
{
if (!this._pendingViewStateCookie)
return;
this._checkForStaleResourcesIfNeeded();
var visibleTreeElements = [];
this.contentTreeOutlines.forEach(function(outline) {
if (outline[WI.NavigationSidebarPanel.IgnoreCookieRestoration])
return;
var currentTreeElement = outline.hasChildren ? outline.children[0] : null;
while (currentTreeElement) {
visibleTreeElements.push(currentTreeElement);
currentTreeElement = currentTreeElement.traverseNextTreeElement(false, null, false);
}
});
this._checkElementsForPendingViewStateCookie(visibleTreeElements, matchTypeOnly);
}
_checkElementsForPendingViewStateCookie(treeElements, matchTypeOnly)
{
if (!this._pendingViewStateCookie)
return;
var cookie = this._pendingViewStateCookie;
function treeElementMatchesCookie(treeElement)
{
if (this._isTreeElementWithoutRepresentedObject(treeElement))
return false;
var representedObject = treeElement.representedObject;
if (!representedObject)
return false;
var typeIdentifier = cookie[WI.TypeIdentifierCookieKey];
if (typeIdentifier !== representedObject.constructor.TypeIdentifier)
return false;
if (matchTypeOnly)
return !!typeIdentifier;
var candidateObjectCookie = {};
if (representedObject.saveIdentityToCookie)
representedObject.saveIdentityToCookie(candidateObjectCookie);
var candidateCookieKeys = Object.keys(candidateObjectCookie);
return candidateCookieKeys.length && candidateCookieKeys.every((key) => candidateObjectCookie[key] === cookie[key]);
}
var matchedElement = null;
treeElements.some((element) => {
if (treeElementMatchesCookie.call(this, element)) {
matchedElement = element;
return true;
}
return false;
});
if (matchedElement) {
let didShowContentView = this.showDefaultContentViewForTreeElement(matchedElement);
if (!didShowContentView)
return;
this._pendingViewStateCookie = null;
// Delay clearing the restoringState flag until the next runloop so listeners
// checking for it in this runloop still know state was being restored.
setTimeout(() => {
this._restoringState = false;
}, 0);
if (this._finalAttemptToRestoreViewStateTimeout) {
clearTimeout(this._finalAttemptToRestoreViewStateTimeout);
this._finalAttemptToRestoreViewStateTimeout = undefined;
}
}
}
_treeElementWasFiltered(treeElement)
{
if (treeElement.selected || treeElement.hidden)
return;
let representedObject = this.currentRepresentedObject;
if (!representedObject || treeElement.representedObject !== representedObject)
return;
const omitFocus = true;
const selectedByUser = false;
const suppressNotification = true;
treeElement.revealAndSelect(omitFocus, selectedByUser, suppressNotification);
}
};
WI.NavigationSidebarPanel.IgnoreCookieRestoration = Symbol("ignore-cookie-restoration");
WI.NavigationSidebarPanel.SuppressFilteringSymbol = Symbol("suppress-filtering");
WI.NavigationSidebarPanel.WasExpandedDuringFilteringSymbol = Symbol("was-expanded-during-filtering");
WI.NavigationSidebarPanel.OverflowShadowElementStyleClassName = "overflow-shadow";
WI.NavigationSidebarPanel.ContentTreeOutlineElementStyleClassName = "navigation-sidebar-panel-content-tree-outline";