src/cobalt/debug/remote/devtools/front_end/persistence/Automapping.js - cobalt - Git at Google

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 export default class Automapping {
   /**
    * @param {!Workspace.Workspace} workspace
    * @param {function(!AutomappingStatus)} onStatusAdded
    * @param {function(!AutomappingStatus)} onStatusRemoved
    */
   constructor(workspace, onStatusAdded, onStatusRemoved) {
     this._workspace = workspace;

     this._onStatusAdded = onStatusAdded;
     this._onStatusRemoved = onStatusRemoved;
     /** @type {!Set<!AutomappingStatus>} */
     this._statuses = new Set();
     this._statusSymbol = Symbol('Automapping.Status');
     this._processingPromiseSymbol = Symbol('Automapping.ProcessingPromise');
     this._metadataSymbol = Symbol('Automapping.Metadata');


     /** @type {!Map<string, !Workspace.UISourceCode>} */
     this._fileSystemUISourceCodes = new Map();
     this._sweepThrottler = new Common.Throttler(100);

     const pathEncoder = new Persistence.PathEncoder();
     this._filesIndex = new FilePathIndex(pathEncoder);
     this._projectFoldersIndex = new FolderIndex(pathEncoder);
     this._activeFoldersIndex = new FolderIndex(pathEncoder);

     /** @type {!Array<function(!Workspace.UISourceCode):boolean>} */
     this._interceptors = [];

     this._workspace.addEventListener(
         Workspace.Workspace.Events.UISourceCodeAdded,
         event => this._onUISourceCodeAdded(/** @type {!Workspace.UISourceCode} */ (event.data)));
     this._workspace.addEventListener(
         Workspace.Workspace.Events.UISourceCodeRemoved,
         event => this._onUISourceCodeRemoved(/** @type {!Workspace.UISourceCode} */ (event.data)));
     this._workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeRenamed, this._onUISourceCodeRenamed, this);
     this._workspace.addEventListener(
         Workspace.Workspace.Events.ProjectAdded,
         event => this._onProjectAdded(/** @type {!Workspace.Project} */ (event.data)), this);
     this._workspace.addEventListener(
         Workspace.Workspace.Events.ProjectRemoved,
         event => this._onProjectRemoved(/** @type {!Workspace.Project} */ (event.data)), this);

     for (const fileSystem of workspace.projects()) {
       this._onProjectAdded(fileSystem);
     }
     for (const uiSourceCode of workspace.uiSourceCodes()) {
       this._onUISourceCodeAdded(uiSourceCode);
     }
   }

   /**
    * @param {function(!Workspace.UISourceCode):boolean} interceptor
    */
   addNetworkInterceptor(interceptor) {
     this._interceptors.push(interceptor);
     this.scheduleRemap();
   }

   scheduleRemap() {
     for (const status of this._statuses.valuesArray()) {
       this._clearNetworkStatus(status.network);
     }
     this._scheduleSweep();
   }

   _scheduleSweep() {
     this._sweepThrottler.schedule(sweepUnmapped.bind(this));

     /**
      * @this {Automapping}
      * @return {!Promise}
      */
     function sweepUnmapped() {
       const networkProjects = this._workspace.projectsForType(Workspace.projectTypes.Network);
       for (const networkProject of networkProjects) {
         for (const uiSourceCode of networkProject.uiSourceCodes()) {
           this._computeNetworkStatus(uiSourceCode);
         }
       }
       this._onSweepHappenedForTest();
       return Promise.resolve();
     }
   }

   _onSweepHappenedForTest() {
   }

   /**
    * @param {!Workspace.Project} project
    */
   _onProjectRemoved(project) {
     for (const uiSourceCode of project.uiSourceCodes()) {
       this._onUISourceCodeRemoved(uiSourceCode);
     }
     if (project.type() !== Workspace.projectTypes.FileSystem) {
       return;
     }
     const fileSystem = /** @type {!Persistence.FileSystemWorkspaceBinding.FileSystem} */ (project);
     for (const gitFolder of fileSystem.initialGitFolders()) {
       this._projectFoldersIndex.removeFolder(gitFolder);
     }
     this._projectFoldersIndex.removeFolder(fileSystem.fileSystemPath());
     this.scheduleRemap();
   }

   /**
    * @param {!Workspace.Project} project
    */
   _onProjectAdded(project) {
     if (project.type() !== Workspace.projectTypes.FileSystem) {
       return;
     }
     const fileSystem = /** @type {!Persistence.FileSystemWorkspaceBinding.FileSystem} */ (project);
     for (const gitFolder of fileSystem.initialGitFolders()) {
       this._projectFoldersIndex.addFolder(gitFolder);
     }
     this._projectFoldersIndex.addFolder(fileSystem.fileSystemPath());
     project.uiSourceCodes().forEach(this._onUISourceCodeAdded.bind(this));
     this.scheduleRemap();
   }

   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _onUISourceCodeAdded(uiSourceCode) {
     const project = uiSourceCode.project();
     if (project.type() === Workspace.projectTypes.FileSystem) {
       if (!Persistence.FileSystemWorkspaceBinding.fileSystemSupportsAutomapping(project)) {
         return;
       }
       this._filesIndex.addPath(uiSourceCode.url());
       this._fileSystemUISourceCodes.set(uiSourceCode.url(), uiSourceCode);
       this._scheduleSweep();
     } else if (project.type() === Workspace.projectTypes.Network) {
       this._computeNetworkStatus(uiSourceCode);
     }
   }

   /**
    * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _onUISourceCodeRemoved(uiSourceCode) {
     if (uiSourceCode.project().type() === Workspace.projectTypes.FileSystem) {
       this._filesIndex.removePath(uiSourceCode.url());
       this._fileSystemUISourceCodes.delete(uiSourceCode.url());
       const status = uiSourceCode[this._statusSymbol];
       if (status) {
         this._clearNetworkStatus(status.network);
       }
     } else if (uiSourceCode.project().type() === Workspace.projectTypes.Network) {
       this._clearNetworkStatus(uiSourceCode);
     }
   }

   /**
    * @param {!Common.Event} event
    */
   _onUISourceCodeRenamed(event) {
     const uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data.uiSourceCode);
     const oldURL = /** @type {string} */ (event.data.oldURL);
     if (uiSourceCode.project().type() !== Workspace.projectTypes.FileSystem) {
       return;
     }

     this._filesIndex.removePath(oldURL);
     this._fileSystemUISourceCodes.delete(oldURL);
     const status = uiSourceCode[this._statusSymbol];
     if (status) {
       this._clearNetworkStatus(status.network);
     }

     this._filesIndex.addPath(uiSourceCode.url());
     this._fileSystemUISourceCodes.set(uiSourceCode.url(), uiSourceCode);
     this._scheduleSweep();
   }

   /**
    * @param {!Workspace.UISourceCode} networkSourceCode
    */
   _computeNetworkStatus(networkSourceCode) {
     if (networkSourceCode[this._processingPromiseSymbol] || networkSourceCode[this._statusSymbol]) {
       return;
     }
     if (this._interceptors.some(interceptor => interceptor(networkSourceCode))) {
       return;
     }
     if (networkSourceCode.url().startsWith('wasm://')) {
       return;
     }
     const createBindingPromise =
         this._createBinding(networkSourceCode).then(validateStatus.bind(this)).then(onStatus.bind(this));
     networkSourceCode[this._processingPromiseSymbol] = createBindingPromise;

     /**
      * @param {?AutomappingStatus} status
      * @return {!Promise<?AutomappingStatus>}
      * @this {Automapping}
      */
     async function validateStatus(status) {
       if (!status) {
         return null;
       }
       if (networkSourceCode[this._processingPromiseSymbol] !== createBindingPromise) {
         return null;
       }
       if (status.network.contentType().isFromSourceMap() || !status.fileSystem.contentType().isTextType()) {
         return status;
       }

       // At the time binding comes, there are multiple user scenarios:
       // 1. Both network and fileSystem files are **not** dirty.
       //    This is a typical scenario when user hasn't done any edits yet to the
       //    files in question.
       // 2. FileSystem file has unsaved changes, network is clear.
       //    This typically happens with CSS files editing. Consider the following
       //    scenario:
       //      - user edits file that has been successfully mapped before
       //      - user doesn't save the file
       //      - user hits reload
       // 3. Network file has either unsaved changes or commits, but fileSystem file is clear.
       //    This typically happens when we've been editing file and then realized we'd like to drop
       //    a folder and persist all the changes.
       // 4. Network file has either unsaved changes or commits, and fileSystem file has unsaved changes.
       //    We consider this to be un-realistic scenario and in this case just fail gracefully.
       //
       // To support usecase (3), we need to validate against original network content.
       if (status.fileSystem.isDirty() && (status.network.isDirty() || status.network.hasCommits())) {
         return null;
       }

       const [fileSystemContent, networkContent] = await Promise.all(
           [status.fileSystem.requestContent(), status.network.project().requestFileContent(status.network)]);
       if (fileSystemContent.content === null || networkContent === null) {
         return null;
       }

       if (networkSourceCode[this._processingPromiseSymbol] !== createBindingPromise) {
         return null;
       }

       const target = Bindings.NetworkProject.targetForUISourceCode(status.network);
       let isValid = false;
       const fileContent = fileSystemContent.content;
       if (target && target.type() === SDK.Target.Type.Node) {
         const rewrappedNetworkContent =
             Persistence.Persistence.rewrapNodeJSContent(status.fileSystem, fileContent, networkContent.content);
         isValid = fileContent === rewrappedNetworkContent;
       } else {
         // Trim trailing whitespaces because V8 adds trailing newline.
         isValid = fileContent.trimRight() === networkContent.content.trimRight();
       }
       if (!isValid) {
         this._prevalidationFailedForTest(status);
         return null;
       }
       return status;
     }

     /**
      * @param {?AutomappingStatus} status
      * @this {Automapping}
      */
     function onStatus(status) {
       if (networkSourceCode[this._processingPromiseSymbol] !== createBindingPromise) {
         return;
       }
       networkSourceCode[this._processingPromiseSymbol] = null;
       if (!status) {
         this._onBindingFailedForTest();
         return;
       }
       // TODO(lushnikov): remove this check once there's a single uiSourceCode per url. @see crbug.com/670180
       if (status.network[this._statusSymbol] || status.fileSystem[this._statusSymbol]) {
         return;
       }

       this._statuses.add(status);
       status.network[this._statusSymbol] = status;
       status.fileSystem[this._statusSymbol] = status;
       if (status.exactMatch) {
         const projectFolder = this._projectFoldersIndex.closestParentFolder(status.fileSystem.url());
         const newFolderAdded = projectFolder ? this._activeFoldersIndex.addFolder(projectFolder) : false;
         if (newFolderAdded) {
           this._scheduleSweep();
         }
       }
       this._onStatusAdded.call(null, status);
     }
   }

   /**
    * @param {!AutomappingStatus} binding
    */
   _prevalidationFailedForTest(binding) {
   }

   _onBindingFailedForTest() {
   }

   /**
    * @param {!Workspace.UISourceCode} networkSourceCode
    */
   _clearNetworkStatus(networkSourceCode) {
     if (networkSourceCode[this._processingPromiseSymbol]) {
       networkSourceCode[this._processingPromiseSymbol] = null;
       return;
     }
     const status = networkSourceCode[this._statusSymbol];
     if (!status) {
       return;
     }

     this._statuses.delete(status);
     status.network[this._statusSymbol] = null;
     status.fileSystem[this._statusSymbol] = null;
     if (status.exactMatch) {
       const projectFolder = this._projectFoldersIndex.closestParentFolder(status.fileSystem.url());
       if (projectFolder) {
         this._activeFoldersIndex.removeFolder(projectFolder);
       }
     }
     this._onStatusRemoved.call(null, status);
   }

   /**
    * @param {!Workspace.UISourceCode} networkSourceCode
    * @return {!Promise<?AutomappingStatus>}
    */
   _createBinding(networkSourceCode) {
     if (networkSourceCode.url().startsWith('file://') || networkSourceCode.url().startsWith('snippet://')) {
       const decodedUrl = decodeURI(networkSourceCode.url());
       const fileSourceCode = this._fileSystemUISourceCodes.get(decodedUrl);
       const status = fileSourceCode ? new AutomappingStatus(networkSourceCode, fileSourceCode, false) : null;
       return Promise.resolve(status);
     }

     let networkPath = Common.ParsedURL.extractPath(networkSourceCode.url());
     if (networkPath === null) {
       return Promise.resolve(/** @type {?AutomappingStatus} */ (null));
     }

     if (networkPath.endsWith('/')) {
       networkPath += 'index.html';
     }
     const urlDecodedNetworkPath = decodeURI(networkPath);
     const similarFiles =
         this._filesIndex.similarFiles(urlDecodedNetworkPath).map(path => this._fileSystemUISourceCodes.get(path));
     if (!similarFiles.length) {
       return Promise.resolve(/** @type {?AutomappingStatus} */ (null));
     }

     return this._pullMetadatas(similarFiles.concat(networkSourceCode)).then(onMetadatas.bind(this));

     /**
      * @this {Automapping}
      */
     function onMetadatas() {
       const activeFiles = similarFiles.filter(file => !!this._activeFoldersIndex.closestParentFolder(file.url()));
       const networkMetadata = networkSourceCode[this._metadataSymbol];
       if (!networkMetadata || (!networkMetadata.modificationTime && typeof networkMetadata.contentSize !== 'number')) {
         // If networkSourceCode does not have metadata, try to match against active folders.
         if (activeFiles.length !== 1) {
           return null;
         }
         return new AutomappingStatus(networkSourceCode, activeFiles[0], false);
       }

       // Try to find exact matches, prioritizing active folders.
       let exactMatches = this._filterWithMetadata(activeFiles, networkMetadata);
       if (!exactMatches.length) {
         exactMatches = this._filterWithMetadata(similarFiles, networkMetadata);
       }
       if (exactMatches.length !== 1) {
         return null;
       }
       return new AutomappingStatus(networkSourceCode, exactMatches[0], true);
     }
   }

   /**
    * @param {!Array<!Workspace.UISourceCode>} uiSourceCodes
    * @return {!Promise}
    */
   _pullMetadatas(uiSourceCodes) {
     return Promise.all(uiSourceCodes.map(async file => {
       file[this._metadataSymbol] = await file.requestMetadata();
     }));
   }

   /**
    * @param {!Array<!Workspace.UISourceCode>} files
    * @param {!Workspace.UISourceCodeMetadata} networkMetadata
    * @return {!Array<!Workspace.UISourceCode>}
    */
   _filterWithMetadata(files, networkMetadata) {
     return files.filter(file => {
       const fileMetadata = file[this._metadataSymbol];
       if (!fileMetadata) {
         return false;
       }
       // Allow a second of difference due to network timestamps lack of precision.
       const timeMatches = !networkMetadata.modificationTime ||
           Math.abs(networkMetadata.modificationTime - fileMetadata.modificationTime) < 1000;
       const contentMatches = !networkMetadata.contentSize || fileMetadata.contentSize === networkMetadata.contentSize;
       return timeMatches && contentMatches;
     });
   }
 }

 /**
  * @unrestricted
  */
 class FilePathIndex {
   /**
    * @param {!Persistence.PathEncoder} encoder
    */
   constructor(encoder) {
     this._encoder = encoder;
     this._reversedIndex = new Common.Trie();
   }

   /**
    * @param {string} path
    */
   addPath(path) {
     const encodedPath = this._encoder.encode(path);
     this._reversedIndex.add(encodedPath.reverse());
   }

   /**
    * @param {string} path
    */
   removePath(path) {
     const encodedPath = this._encoder.encode(path);
     this._reversedIndex.remove(encodedPath.reverse());
   }

   /**
    * @param {string} networkPath
    * @return {!Array<string>}
    */
   similarFiles(networkPath) {
     const encodedPath = this._encoder.encode(networkPath);
     const longestCommonPrefix = this._reversedIndex.longestPrefix(encodedPath.reverse(), false);
     if (!longestCommonPrefix) {
       return [];
     }
     return this._reversedIndex.words(longestCommonPrefix)
         .map(encodedPath => this._encoder.decode(encodedPath.reverse()));
   }
 }

 /**
  * @unrestricted
  */
 class FolderIndex {
   /**
    * @param {!Persistence.PathEncoder} encoder
    */
   constructor(encoder) {
     this._encoder = encoder;
     this._index = new Common.Trie();
     /** @type {!Map<string, number>} */
     this._folderCount = new Map();
   }

   /**
    * @param {string} path
    * @return {boolean}
    */
   addFolder(path) {
     if (path.endsWith('/')) {
       path = path.substring(0, path.length - 1);
     }
     const encodedPath = this._encoder.encode(path);
     this._index.add(encodedPath);
     const count = this._folderCount.get(encodedPath) || 0;
     this._folderCount.set(encodedPath, count + 1);
     return count === 0;
   }

   /**
    * @param {string} path
    * @return {boolean}
    */
   removeFolder(path) {
     if (path.endsWith('/')) {
       path = path.substring(0, path.length - 1);
     }
     const encodedPath = this._encoder.encode(path);
     const count = this._folderCount.get(encodedPath) || 0;
     if (!count) {
       return false;
     }
     if (count > 1) {
       this._folderCount.set(encodedPath, count - 1);
       return false;
     }
     this._index.remove(encodedPath);
     this._folderCount.delete(encodedPath);
     return true;
   }

   /**
    * @param {string} path
    * @return {string}
    */
   closestParentFolder(path) {
     const encodedPath = this._encoder.encode(path);
     const commonPrefix = this._index.longestPrefix(encodedPath, true);
     return this._encoder.decode(commonPrefix);
   }
 }

 /**
  * @unrestricted
  */
 export class AutomappingStatus {
   /**
    * @param {!Workspace.UISourceCode} network
    * @param {!Workspace.UISourceCode} fileSystem
    * @param {boolean} exactMatch
    */
   constructor(network, fileSystem, exactMatch) {
     this.network = network;
     this.fileSystem = fileSystem;
     this.exactMatch = exactMatch;
   }
 }

 /* Legacy exported object */
 self.Persistence = self.Persistence || {};

 /* Legacy exported object */
 Persistence = Persistence || {};

 /** @constructor */
 Persistence.Automapping = Automapping;

 /** @constructor */
 Persistence.AutomappingStatus = AutomappingStatus;
	// Copyright 2016 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	export default class Automapping {
	/**
	* @param {!Workspace.Workspace} workspace
	* @param {function(!AutomappingStatus)} onStatusAdded
	* @param {function(!AutomappingStatus)} onStatusRemoved
	*/
	constructor(workspace, onStatusAdded, onStatusRemoved) {
	this._workspace = workspace;

	this._onStatusAdded = onStatusAdded;
	this._onStatusRemoved = onStatusRemoved;
	/** @type {!Set<!AutomappingStatus>} */
	this._statuses = new Set();
	this._statusSymbol = Symbol('Automapping.Status');
	this._processingPromiseSymbol = Symbol('Automapping.ProcessingPromise');
	this._metadataSymbol = Symbol('Automapping.Metadata');


	/** @type {!Map<string, !Workspace.UISourceCode>} */
	this._fileSystemUISourceCodes = new Map();
	this._sweepThrottler = new Common.Throttler(100);

	const pathEncoder = new Persistence.PathEncoder();
	this._filesIndex = new FilePathIndex(pathEncoder);
	this._projectFoldersIndex = new FolderIndex(pathEncoder);
	this._activeFoldersIndex = new FolderIndex(pathEncoder);

	/** @type {!Array<function(!Workspace.UISourceCode):boolean>} */
	this._interceptors = [];

	this._workspace.addEventListener(
	Workspace.Workspace.Events.UISourceCodeAdded,
	event => this._onUISourceCodeAdded(/** @type {!Workspace.UISourceCode} */ (event.data)));
	this._workspace.addEventListener(
	Workspace.Workspace.Events.UISourceCodeRemoved,
	event => this._onUISourceCodeRemoved(/** @type {!Workspace.UISourceCode} */ (event.data)));
	this._workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeRenamed, this._onUISourceCodeRenamed, this);
	this._workspace.addEventListener(
	Workspace.Workspace.Events.ProjectAdded,
	event => this._onProjectAdded(/** @type {!Workspace.Project} */ (event.data)), this);
	this._workspace.addEventListener(
	Workspace.Workspace.Events.ProjectRemoved,
	event => this._onProjectRemoved(/** @type {!Workspace.Project} */ (event.data)), this);

	for (const fileSystem of workspace.projects()) {
	this._onProjectAdded(fileSystem);
	}
	for (const uiSourceCode of workspace.uiSourceCodes()) {
	this._onUISourceCodeAdded(uiSourceCode);
	}
	}

	/**
	* @param {function(!Workspace.UISourceCode):boolean} interceptor
	*/
	addNetworkInterceptor(interceptor) {
	this._interceptors.push(interceptor);
	this.scheduleRemap();
	}

	scheduleRemap() {
	for (const status of this._statuses.valuesArray()) {
	this._clearNetworkStatus(status.network);
	}
	this._scheduleSweep();
	}

	_scheduleSweep() {
	this._sweepThrottler.schedule(sweepUnmapped.bind(this));

	/**
	* @this {Automapping}
	* @return {!Promise}
	*/
	function sweepUnmapped() {
	const networkProjects = this._workspace.projectsForType(Workspace.projectTypes.Network);
	for (const networkProject of networkProjects) {
	for (const uiSourceCode of networkProject.uiSourceCodes()) {
	this._computeNetworkStatus(uiSourceCode);
	}
	}
	this._onSweepHappenedForTest();
	return Promise.resolve();
	}
	}

	_onSweepHappenedForTest() {
	}

	/**
	* @param {!Workspace.Project} project
	*/
	_onProjectRemoved(project) {
	for (const uiSourceCode of project.uiSourceCodes()) {
	this._onUISourceCodeRemoved(uiSourceCode);
	}
	if (project.type() !== Workspace.projectTypes.FileSystem) {
	return;
	}
	const fileSystem = /** @type {!Persistence.FileSystemWorkspaceBinding.FileSystem} */ (project);
	for (const gitFolder of fileSystem.initialGitFolders()) {
	this._projectFoldersIndex.removeFolder(gitFolder);
	}
	this._projectFoldersIndex.removeFolder(fileSystem.fileSystemPath());
	this.scheduleRemap();
	}

	/**
	* @param {!Workspace.Project} project
	*/
	_onProjectAdded(project) {
	if (project.type() !== Workspace.projectTypes.FileSystem) {
	return;
	}
	const fileSystem = /** @type {!Persistence.FileSystemWorkspaceBinding.FileSystem} */ (project);
	for (const gitFolder of fileSystem.initialGitFolders()) {
	this._projectFoldersIndex.addFolder(gitFolder);
	}
	this._projectFoldersIndex.addFolder(fileSystem.fileSystemPath());
	project.uiSourceCodes().forEach(this._onUISourceCodeAdded.bind(this));
	this.scheduleRemap();
	}

	/**
	* @param {!Workspace.UISourceCode} uiSourceCode
	*/
	_onUISourceCodeAdded(uiSourceCode) {
	const project = uiSourceCode.project();
	if (project.type() === Workspace.projectTypes.FileSystem) {
	if (!Persistence.FileSystemWorkspaceBinding.fileSystemSupportsAutomapping(project)) {
	return;
	}
	this._filesIndex.addPath(uiSourceCode.url());
	this._fileSystemUISourceCodes.set(uiSourceCode.url(), uiSourceCode);
	this._scheduleSweep();
	} else if (project.type() === Workspace.projectTypes.Network) {
	this._computeNetworkStatus(uiSourceCode);
	}
	}

	/**
	* @param {!Workspace.UISourceCode} uiSourceCode
	*/
	_onUISourceCodeRemoved(uiSourceCode) {
	if (uiSourceCode.project().type() === Workspace.projectTypes.FileSystem) {
	this._filesIndex.removePath(uiSourceCode.url());
	this._fileSystemUISourceCodes.delete(uiSourceCode.url());
	const status = uiSourceCode[this._statusSymbol];
	if (status) {
	this._clearNetworkStatus(status.network);
	}
	} else if (uiSourceCode.project().type() === Workspace.projectTypes.Network) {
	this._clearNetworkStatus(uiSourceCode);
	}
	}

	/**
	* @param {!Common.Event} event
	*/
	_onUISourceCodeRenamed(event) {
	const uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data.uiSourceCode);
	const oldURL = /** @type {string} */ (event.data.oldURL);
	if (uiSourceCode.project().type() !== Workspace.projectTypes.FileSystem) {
	return;
	}

	this._filesIndex.removePath(oldURL);
	this._fileSystemUISourceCodes.delete(oldURL);
	const status = uiSourceCode[this._statusSymbol];
	if (status) {
	this._clearNetworkStatus(status.network);
	}

	this._filesIndex.addPath(uiSourceCode.url());
	this._fileSystemUISourceCodes.set(uiSourceCode.url(), uiSourceCode);
	this._scheduleSweep();
	}

	/**
	* @param {!Workspace.UISourceCode} networkSourceCode
	*/
	_computeNetworkStatus(networkSourceCode) {
	if (networkSourceCode[this._processingPromiseSymbol] \|\| networkSourceCode[this._statusSymbol]) {
	return;
	}
	if (this._interceptors.some(interceptor => interceptor(networkSourceCode))) {
	return;
	}
	if (networkSourceCode.url().startsWith('wasm://')) {
	return;
	}
	const createBindingPromise =
	this._createBinding(networkSourceCode).then(validateStatus.bind(this)).then(onStatus.bind(this));
	networkSourceCode[this._processingPromiseSymbol] = createBindingPromise;

	/**
	* @param {?AutomappingStatus} status
	* @return {!Promise<?AutomappingStatus>}
	* @this {Automapping}
	*/
	async function validateStatus(status) {
	if (!status) {
	return null;
	}
	if (networkSourceCode[this._processingPromiseSymbol] !== createBindingPromise) {
	return null;
	}
	if (status.network.contentType().isFromSourceMap() \|\| !status.fileSystem.contentType().isTextType()) {
	return status;
	}

	// At the time binding comes, there are multiple user scenarios:
	// 1. Both network and fileSystem files are not dirty.
	// This is a typical scenario when user hasn't done any edits yet to the
	// files in question.
	// 2. FileSystem file has unsaved changes, network is clear.
	// This typically happens with CSS files editing. Consider the following
	// scenario:
	// - user edits file that has been successfully mapped before
	// - user doesn't save the file
	// - user hits reload
	// 3. Network file has either unsaved changes or commits, but fileSystem file is clear.
	// This typically happens when we've been editing file and then realized we'd like to drop
	// a folder and persist all the changes.
	// 4. Network file has either unsaved changes or commits, and fileSystem file has unsaved changes.
	// We consider this to be un-realistic scenario and in this case just fail gracefully.
	//
	// To support usecase (3), we need to validate against original network content.
	if (status.fileSystem.isDirty() && (status.network.isDirty() \|\| status.network.hasCommits())) {
	return null;
	}

	const [fileSystemContent, networkContent] = await Promise.all(
	[status.fileSystem.requestContent(), status.network.project().requestFileContent(status.network)]);
	if (fileSystemContent.content === null \|\| networkContent === null) {
	return null;
	}

	if (networkSourceCode[this._processingPromiseSymbol] !== createBindingPromise) {
	return null;
	}

	const target = Bindings.NetworkProject.targetForUISourceCode(status.network);
	let isValid = false;
	const fileContent = fileSystemContent.content;
	if (target && target.type() === SDK.Target.Type.Node) {
	const rewrappedNetworkContent =
	Persistence.Persistence.rewrapNodeJSContent(status.fileSystem, fileContent, networkContent.content);
	isValid = fileContent === rewrappedNetworkContent;
	} else {
	// Trim trailing whitespaces because V8 adds trailing newline.
	isValid = fileContent.trimRight() === networkContent.content.trimRight();
	}
	if (!isValid) {
	this._prevalidationFailedForTest(status);
	return null;
	}
	return status;
	}

	/**
	* @param {?AutomappingStatus} status
	* @this {Automapping}
	*/
	function onStatus(status) {
	if (networkSourceCode[this._processingPromiseSymbol] !== createBindingPromise) {
	return;
	}
	networkSourceCode[this._processingPromiseSymbol] = null;
	if (!status) {
	this._onBindingFailedForTest();
	return;
	}
	// TODO(lushnikov): remove this check once there's a single uiSourceCode per url. @see crbug.com/670180
	if (status.network[this._statusSymbol] \|\| status.fileSystem[this._statusSymbol]) {
	return;
	}

	this._statuses.add(status);
	status.network[this._statusSymbol] = status;
	status.fileSystem[this._statusSymbol] = status;
	if (status.exactMatch) {
	const projectFolder = this._projectFoldersIndex.closestParentFolder(status.fileSystem.url());
	const newFolderAdded = projectFolder ? this._activeFoldersIndex.addFolder(projectFolder) : false;
	if (newFolderAdded) {
	this._scheduleSweep();
	}
	}
	this._onStatusAdded.call(null, status);
	}
	}

	/**
	* @param {!AutomappingStatus} binding
	*/
	_prevalidationFailedForTest(binding) {
	}

	_onBindingFailedForTest() {
	}

	/**
	* @param {!Workspace.UISourceCode} networkSourceCode
	*/
	_clearNetworkStatus(networkSourceCode) {
	if (networkSourceCode[this._processingPromiseSymbol]) {
	networkSourceCode[this._processingPromiseSymbol] = null;
	return;
	}
	const status = networkSourceCode[this._statusSymbol];
	if (!status) {
	return;
	}

	this._statuses.delete(status);
	status.network[this._statusSymbol] = null;
	status.fileSystem[this._statusSymbol] = null;
	if (status.exactMatch) {
	const projectFolder = this._projectFoldersIndex.closestParentFolder(status.fileSystem.url());
	if (projectFolder) {
	this._activeFoldersIndex.removeFolder(projectFolder);
	}
	}
	this._onStatusRemoved.call(null, status);
	}

	/**
	* @param {!Workspace.UISourceCode} networkSourceCode
	* @return {!Promise<?AutomappingStatus>}
	*/
	_createBinding(networkSourceCode) {
	if (networkSourceCode.url().startsWith('file://') \|\| networkSourceCode.url().startsWith('snippet://')) {
	const decodedUrl = decodeURI(networkSourceCode.url());
	const fileSourceCode = this._fileSystemUISourceCodes.get(decodedUrl);
	const status = fileSourceCode ? new AutomappingStatus(networkSourceCode, fileSourceCode, false) : null;
	return Promise.resolve(status);
	}

	let networkPath = Common.ParsedURL.extractPath(networkSourceCode.url());
	if (networkPath === null) {
	return Promise.resolve(/** @type {?AutomappingStatus} */ (null));
	}

	if (networkPath.endsWith('/')) {
	networkPath += 'index.html';
	}
	const urlDecodedNetworkPath = decodeURI(networkPath);
	const similarFiles =
	this._filesIndex.similarFiles(urlDecodedNetworkPath).map(path => this._fileSystemUISourceCodes.get(path));
	if (!similarFiles.length) {
	return Promise.resolve(/** @type {?AutomappingStatus} */ (null));
	}

	return this._pullMetadatas(similarFiles.concat(networkSourceCode)).then(onMetadatas.bind(this));

	/**
	* @this {Automapping}
	*/
	function onMetadatas() {
	const activeFiles = similarFiles.filter(file => !!this._activeFoldersIndex.closestParentFolder(file.url()));
	const networkMetadata = networkSourceCode[this._metadataSymbol];
	if (!networkMetadata \|\| (!networkMetadata.modificationTime && typeof networkMetadata.contentSize !== 'number')) {
	// If networkSourceCode does not have metadata, try to match against active folders.
	if (activeFiles.length !== 1) {
	return null;
	}
	return new AutomappingStatus(networkSourceCode, activeFiles[0], false);
	}

	// Try to find exact matches, prioritizing active folders.
	let exactMatches = this._filterWithMetadata(activeFiles, networkMetadata);
	if (!exactMatches.length) {
	exactMatches = this._filterWithMetadata(similarFiles, networkMetadata);
	}
	if (exactMatches.length !== 1) {
	return null;
	}
	return new AutomappingStatus(networkSourceCode, exactMatches[0], true);
	}
	}

	/**
	* @param {!Array<!Workspace.UISourceCode>} uiSourceCodes
	* @return {!Promise}
	*/
	_pullMetadatas(uiSourceCodes) {
	return Promise.all(uiSourceCodes.map(async file => {
	file[this._metadataSymbol] = await file.requestMetadata();
	}));
	}

	/**
	* @param {!Array<!Workspace.UISourceCode>} files
	* @param {!Workspace.UISourceCodeMetadata} networkMetadata
	* @return {!Array<!Workspace.UISourceCode>}
	*/
	_filterWithMetadata(files, networkMetadata) {
	return files.filter(file => {
	const fileMetadata = file[this._metadataSymbol];
	if (!fileMetadata) {
	return false;
	}
	// Allow a second of difference due to network timestamps lack of precision.
	const timeMatches = !networkMetadata.modificationTime \|\|
	Math.abs(networkMetadata.modificationTime - fileMetadata.modificationTime) < 1000;
	const contentMatches = !networkMetadata.contentSize \|\| fileMetadata.contentSize === networkMetadata.contentSize;
	return timeMatches && contentMatches;
	});
	}
	}

	/**
	* @unrestricted
	*/
	class FilePathIndex {
	/**
	* @param {!Persistence.PathEncoder} encoder
	*/
	constructor(encoder) {
	this._encoder = encoder;
	this._reversedIndex = new Common.Trie();
	}

	/**
	* @param {string} path
	*/
	addPath(path) {
	const encodedPath = this._encoder.encode(path);
	this._reversedIndex.add(encodedPath.reverse());
	}

	/**
	* @param {string} path
	*/
	removePath(path) {
	const encodedPath = this._encoder.encode(path);
	this._reversedIndex.remove(encodedPath.reverse());
	}

	/**
	* @param {string} networkPath
	* @return {!Array<string>}
	*/
	similarFiles(networkPath) {
	const encodedPath = this._encoder.encode(networkPath);
	const longestCommonPrefix = this._reversedIndex.longestPrefix(encodedPath.reverse(), false);
	if (!longestCommonPrefix) {
	return [];
	}
	return this._reversedIndex.words(longestCommonPrefix)
	.map(encodedPath => this._encoder.decode(encodedPath.reverse()));
	}
	}

	/**
	* @unrestricted
	*/
	class FolderIndex {
	/**
	* @param {!Persistence.PathEncoder} encoder
	*/
	constructor(encoder) {
	this._encoder = encoder;
	this._index = new Common.Trie();
	/** @type {!Map<string, number>} */
	this._folderCount = new Map();
	}

	/**
	* @param {string} path
	* @return {boolean}
	*/
	addFolder(path) {
	if (path.endsWith('/')) {
	path = path.substring(0, path.length - 1);
	}
	const encodedPath = this._encoder.encode(path);
	this._index.add(encodedPath);
	const count = this._folderCount.get(encodedPath) \|\| 0;
	this._folderCount.set(encodedPath, count + 1);
	return count === 0;
	}

	/**
	* @param {string} path
	* @return {boolean}
	*/
	removeFolder(path) {
	if (path.endsWith('/')) {
	path = path.substring(0, path.length - 1);
	}
	const encodedPath = this._encoder.encode(path);
	const count = this._folderCount.get(encodedPath) \|\| 0;
	if (!count) {
	return false;
	}
	if (count > 1) {
	this._folderCount.set(encodedPath, count - 1);
	return false;
	}
	this._index.remove(encodedPath);
	this._folderCount.delete(encodedPath);
	return true;
	}

	/**
	* @param {string} path
	* @return {string}
	*/
	closestParentFolder(path) {
	const encodedPath = this._encoder.encode(path);
	const commonPrefix = this._index.longestPrefix(encodedPath, true);
	return this._encoder.decode(commonPrefix);
	}
	}

	/**
	* @unrestricted
	*/
	export class AutomappingStatus {
	/**
	* @param {!Workspace.UISourceCode} network
	* @param {!Workspace.UISourceCode} fileSystem
	* @param {boolean} exactMatch
	*/
	constructor(network, fileSystem, exactMatch) {
	this.network = network;
	this.fileSystem = fileSystem;
	this.exactMatch = exactMatch;
	}
	}

	/* Legacy exported object */
	self.Persistence = self.Persistence \|\| {};

	/* Legacy exported object */
	Persistence = Persistence \|\| {};

	/** @constructor */
	Persistence.Automapping = Automapping;

	/** @constructor */
	Persistence.AutomappingStatus = AutomappingStatus;