chrome-devtools-frontend 1.0.981004 → 1.0.995227

package/front_end/models/persistence/FileSystemWorkspaceBinding.ts

@@ -28,8 +28,6 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// TODO(crbug.com/1253323): Cast to Branded Types will be removed from this file when migration to branded types is complete.
-
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as TextUtils from '../text_utils/text_utils.js';
@@ -57,13 +55,14 @@ export class FileSystemWorkspaceBinding {
     void this.isolatedFileSystemManager.waitForFileSystems().then(this.onFileSystemsLoaded.bind(this));
   }
 
-  static projectId(fileSystemPath: string): string {
+  static projectId(fileSystemPath: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString {
     return fileSystemPath;
   }
 
   static relativePath(uiSourceCode: Workspace.UISourceCode.UISourceCode): Platform.DevToolsPath.EncodedPathString[] {
     const baseURL = (uiSourceCode.project() as FileSystem).fileSystemBaseURL;
-    return uiSourceCode.url().substring(baseURL.length).split('/') as Platform.DevToolsPath.EncodedPathString[];
+    return Common.ParsedURL.ParsedURL.split(
+        Common.ParsedURL.ParsedURL.sliceUrlToEncodedPathString(uiSourceCode.url(), baseURL.length), '/');
   }
 
   static tooltipForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): string {
@@ -86,7 +85,7 @@ export class FileSystemWorkspaceBinding {
     return Common.ParsedURL.ParsedURL.concatenate(fsProject.fileSystemBaseURL, relativePath);
   }
 
-  static fileSystemPath(projectId: string): string {
+  static fileSystemPath(projectId: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString {
     return projectId;
   }
 
@@ -158,9 +157,9 @@ export class FileSystemWorkspaceBinding {
 export class FileSystem extends Workspace.Workspace.ProjectStore {
   readonly fileSystemInternal: PlatformFileSystem;
   readonly fileSystemBaseURL: Platform.DevToolsPath.UrlString;
-  private readonly fileSystemParentURL: string;
+  private readonly fileSystemParentURL: Platform.DevToolsPath.UrlString;
   private readonly fileSystemWorkspaceBinding: FileSystemWorkspaceBinding;
-  private readonly fileSystemPathInternal: string;
+  private readonly fileSystemPathInternal: Platform.DevToolsPath.UrlString;
   private readonly creatingFilesGuard: Set<string>;
   constructor(
       fileSystemWorkspaceBinding: FileSystemWorkspaceBinding, isolatedFileSystem: PlatformFileSystem,
@@ -174,7 +173,8 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
 
     this.fileSystemInternal = isolatedFileSystem;
     this.fileSystemBaseURL = Common.ParsedURL.ParsedURL.concatenate(this.fileSystemInternal.path(), '/');
-    this.fileSystemParentURL = this.fileSystemBaseURL.substr(0, fileSystemPath.lastIndexOf('/') + 1);
+    this.fileSystemParentURL =
+        Common.ParsedURL.ParsedURL.substr(this.fileSystemBaseURL, 0, fileSystemPath.lastIndexOf('/') + 1);
     this.fileSystemWorkspaceBinding = fileSystemWorkspaceBinding;
     this.fileSystemPathInternal = fileSystemPath;
     this.creatingFilesGuard = new Set();
@@ -183,7 +183,7 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
     this.populate();
   }
 
-  fileSystemPath(): string {
+  fileSystemPath(): Platform.DevToolsPath.UrlString {
     return this.fileSystemPathInternal;
   }
 
@@ -195,9 +195,9 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
     return this.fileSystemInternal.mimeFromPath(uiSourceCode.url());
   }
 
-  initialGitFolders(): Platform.DevToolsPath.EncodedPathString[] {
-    return this.fileSystemInternal.initialGitFolders().map(folder => this.fileSystemPathInternal + '/' + folder) as
-        Platform.DevToolsPath.EncodedPathString[];
+  initialGitFolders(): Platform.DevToolsPath.UrlString[] {
+    return this.fileSystemInternal.initialGitFolders().map(
+        folder => Common.ParsedURL.ParsedURL.concatenate(this.fileSystemPathInternal, '/', folder));
   }
 
   private filePathForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode):
@@ -262,7 +262,7 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
   rename(
       uiSourceCode: Workspace.UISourceCode.UISourceCode, newName: Platform.DevToolsPath.RawPathString,
       callback:
-          (arg0: boolean, arg1?: string|undefined, arg2?: string|undefined,
+          (arg0: boolean, arg1?: string|undefined, arg2?: Platform.DevToolsPath.UrlString|undefined,
            arg3?: Common.ResourceType.ResourceType|undefined) => void): void {
     if (newName === uiSourceCode.name()) {
       callback(true, uiSourceCode.name(), uiSourceCode.url(), uiSourceCode.contentType());
@@ -282,7 +282,7 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
       const parentPath = Common.ParsedURL.ParsedURL.substr(filePath, 0, slash);
       filePath = Common.ParsedURL.ParsedURL.encodedFromParentPathAndName(parentPath, newName);
       filePath = Common.ParsedURL.ParsedURL.substr(filePath, 1);
-      const newURL = this.fileSystemBaseURL + filePath;
+      const newURL = Common.ParsedURL.ParsedURL.concatenate(this.fileSystemBaseURL, filePath);
       const newContentType = this.fileSystemInternal.contentType(newName);
       this.renameUISourceCode(uiSourceCode, newName);
       callback(true, newName, newURL, newContentType);
@@ -301,9 +301,9 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
   }
 
   async findFilesMatchingSearchRequest(
-      searchConfig: Workspace.Workspace.ProjectSearchConfig, filesMathingFileQuery: string[],
+      searchConfig: Workspace.Workspace.ProjectSearchConfig, filesMatchingFileQuery: Platform.DevToolsPath.UrlString[],
       progress: Common.Progress.Progress): Promise<string[]> {
-    let result: string[] = filesMathingFileQuery;
+    let result: string[] = filesMatchingFileQuery;
     const queriesToRun = searchConfig.queries().slice();
     if (!queriesToRun.length) {
       queriesToRun.push('');
@@ -341,9 +341,8 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
     }
   }
 
-  excludeFolder(url: string): void {
-    let relativeFolder = Common.ParsedURL.ParsedURL.sliceUrlToEncodedPathString(
-        url as Platform.DevToolsPath.UrlString, this.fileSystemBaseURL.length);
+  excludeFolder(url: Platform.DevToolsPath.UrlString): void {
+    let relativeFolder = Common.ParsedURL.ParsedURL.sliceUrlToEncodedPathString(url, this.fileSystemBaseURL.length);
     if (!relativeFolder.startsWith('/')) {
       relativeFolder = Common.ParsedURL.ParsedURL.prepend('/', relativeFolder);
     }
@@ -399,12 +398,13 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
 
   private addFile(filePath: Platform.DevToolsPath.EncodedPathString): Workspace.UISourceCode.UISourceCode {
     const contentType = this.fileSystemInternal.contentType(filePath);
-    const uiSourceCode = this.createUISourceCode(this.fileSystemBaseURL + filePath, contentType);
+    const uiSourceCode =
+        this.createUISourceCode(Common.ParsedURL.ParsedURL.concatenate(this.fileSystemBaseURL, filePath), contentType);
     this.addUISourceCode(uiSourceCode);
     return uiSourceCode;
   }
 
-  fileChanged(path: string): void {
+  fileChanged(path: Platform.DevToolsPath.UrlString): void {
     // Ignore files that are being created but do not have content yet.
     if (this.creatingFilesGuard.has(path)) {
       return;
@@ -431,7 +431,7 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
 const sourceCodeToMetadataMap =
     new WeakMap<Workspace.UISourceCode.UISourceCode, Promise<Workspace.UISourceCode.UISourceCodeMetadata|null>>();
 export interface FilesChangedData {
-  changed: Platform.MapUtilities.Multimap<string, string>;
-  added: Platform.MapUtilities.Multimap<string, string>;
-  removed: Platform.MapUtilities.Multimap<string, string>;
+  changed: Platform.MapUtilities.Multimap<Platform.DevToolsPath.UrlString, Platform.DevToolsPath.UrlString>;
+  added: Platform.MapUtilities.Multimap<Platform.DevToolsPath.UrlString, Platform.DevToolsPath.UrlString>;
+  removed: Platform.MapUtilities.Multimap<Platform.DevToolsPath.UrlString, Platform.DevToolsPath.UrlString>;
 }

package/front_end/models/persistence/IsolatedFileSystem.ts

@@ -532,7 +532,7 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return Boolean(regex && regex.test(Common.ParsedURL.ParsedURL.encodedPathToRawPathString(folderPath)));
   }
 
-  excludedFolders(): Set<string> {
+  excludedFolders(): Set<Platform.DevToolsPath.EncodedPathString> {
     return this.excludedFoldersInternal;
   }
 
@@ -556,7 +556,7 @@ export class IsolatedFileSystem extends PlatformFileSystem {
         requestId, this.embedderPathInternal, JSON.stringify(this.excludedEmbedderFolders));
   }
 
-  mimeFromPath(path: string): string {
+  mimeFromPath(path: Platform.DevToolsPath.UrlString): string {
     return Common.ResourceType.ResourceType.mimeFromURL(path) || 'text/plain';
   }
 

package/front_end/models/persistence/IsolatedFileSystemManager.ts

@@ -50,7 +50,7 @@ const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 let isolatedFileSystemManagerInstance: IsolatedFileSystemManager;
 
 export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
-  private readonly fileSystemsInternal: Map<string, PlatformFileSystem>;
+  private readonly fileSystemsInternal: Map<Platform.DevToolsPath.UrlString, PlatformFileSystem>;
   private readonly callbacks: Map<number, (arg0: Array<Platform.DevToolsPath.RawPathString>) => void>;
   private readonly progresses: Map<number, Common.Progress.Progress>;
   private readonly workspaceFolderExcludePatternSettingInternal: Common.Settings.RegExpSetting;
@@ -191,7 +191,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     }
   }
 
-  addPlatformFileSystem(fileSystemURL: string, fileSystem: PlatformFileSystem): void {
+  addPlatformFileSystem(fileSystemURL: Platform.DevToolsPath.UrlString, fileSystem: PlatformFileSystem): void {
     this.fileSystemsInternal.set(fileSystemURL, fileSystem);
     this.dispatchEventToListeners(Events.FileSystemAdded, fileSystem);
   }
@@ -241,9 +241,10 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     this.dispatchEventToListeners(Events.FileSystemFilesChanged, urlPaths);
 
     function groupFilePathsIntoFileSystemPaths(
-        this: IsolatedFileSystemManager,
-        embedderPaths: Platform.DevToolsPath.RawPathString[]): Platform.MapUtilities.Multimap<string, string> {
-      const paths = new Platform.MapUtilities.Multimap<string, string>();
+        this: IsolatedFileSystemManager, embedderPaths: Platform.DevToolsPath.RawPathString[]):
+        Platform.MapUtilities.Multimap<Platform.DevToolsPath.UrlString, Platform.DevToolsPath.UrlString> {
+      const paths =
+          new Platform.MapUtilities.Multimap<Platform.DevToolsPath.UrlString, Platform.DevToolsPath.UrlString>();
       for (const embedderPath of embedderPaths) {
         const filePath = Common.ParsedURL.ParsedURL.rawPathToUrlString(embedderPath);
         for (const fileSystemPath of this.fileSystemsInternal.keys()) {
@@ -267,7 +268,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     return [...this.fileSystemsInternal.values()];
   }
 
-  fileSystem(fileSystemPath: string): PlatformFileSystem|null {
+  fileSystem(fileSystemPath: Platform.DevToolsPath.UrlString): PlatformFileSystem|null {
     return this.fileSystemsInternal.get(fileSystemPath) || null;
   }
 

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
+import * as Host from '../../core/host/host.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
@@ -23,7 +24,8 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   private readonly savingSymbol: symbol;
   private enabledSetting: Common.Settings.Setting<boolean>;
   private readonly workspace: Workspace.Workspace.WorkspaceImpl;
-  private readonly networkUISourceCodeForEncodedPath: Map<string, Workspace.UISourceCode.UISourceCode>;
+  private readonly networkUISourceCodeForEncodedPath:
+      Map<Platform.DevToolsPath.EncodedPathString, Workspace.UISourceCode.UISourceCode>;
   private readonly interceptionHandlerBound:
       (interceptedRequest: SDK.NetworkManager.InterceptedRequest) => Promise<void>;
   private readonly updateInterceptionThrottler: Common.Throttler.Throttler;
@@ -32,7 +34,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   private activeInternal: boolean;
   private enabled: boolean;
   private eventDescriptors: Common.EventTarget.EventDescriptor[];
-  #headerOverridesMap: Map<string, HeaderOverrideWithRegex[]> = new Map();
+  #headerOverridesMap: Map<Platform.DevToolsPath.EncodedPathString, HeaderOverrideWithRegex[]> = new Map();
 
   private constructor(workspace: Workspace.Workspace.WorkspaceImpl) {
     super();
@@ -185,22 +187,29 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     PersistenceImpl.instance().refreshAutomapping();
   }
 
-  private encodedPathFromUrl(url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.EncodedPathString {
-    if (!this.activeInternal || !this.projectInternal) {
-      return Platform.DevToolsPath.EmptyEncodedPathString;
+  encodedPathFromUrl(url: Platform.DevToolsPath.UrlString, ignoreInactive?: boolean):
+      Platform.DevToolsPath.EncodedPathString {
+    return Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(this.rawPathFromUrl(url, ignoreInactive));
+  }
+
+  rawPathFromUrl(url: Platform.DevToolsPath.UrlString, ignoreInactive?: boolean): Platform.DevToolsPath.RawPathString {
+    if ((!this.activeInternal && !ignoreInactive) || !this.projectInternal) {
+      return Platform.DevToolsPath.EmptyRawPathString;
     }
-    let urlPath = Common.ParsedURL.ParsedURL.urlWithoutHash(url.replace(/^https?:\/\//, ''));
-    if (urlPath.endsWith('/') && urlPath.indexOf('?') === -1) {
-      urlPath = urlPath + 'index.html';
+    let initialEncodedPath = Common.ParsedURL.ParsedURL.urlWithoutHash(url.replace(/^https?:\/\//, '')) as
+        Platform.DevToolsPath.EncodedPathString;
+    if (initialEncodedPath.endsWith('/') && initialEncodedPath.indexOf('?') === -1) {
+      initialEncodedPath = Common.ParsedURL.ParsedURL.concatenate(initialEncodedPath, 'index.html');
     }
-    let encodedPathParts = encodeUrlPathToLocalPathParts(urlPath);
-    const projectPath = FileSystemWorkspaceBinding.fileSystemPath(this.projectInternal.id());
+    let encodedPathParts = encodeEncodedPathToLocalPathParts(initialEncodedPath);
+    const projectPath =
+        FileSystemWorkspaceBinding.fileSystemPath(this.projectInternal.id() as Platform.DevToolsPath.UrlString);
     const encodedPath = encodedPathParts.join('/');
     if (projectPath.length + encodedPath.length > 200) {
       const domain = encodedPathParts[0];
       const encodedFileName = encodedPathParts[encodedPathParts.length - 1];
       const shortFileName = encodedFileName ? encodedFileName.substr(0, 10) + '-' : '';
-      const extension = Common.ParsedURL.ParsedURL.extractExtension(urlPath);
+      const extension = Common.ParsedURL.ParsedURL.extractExtension(initialEncodedPath);
       const extensionPart = extension ? '.' + extension.substr(0, 10) : '';
       encodedPathParts = [
         domain,
@@ -208,49 +217,59 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
         shortFileName + Platform.StringUtilities.hashCode(encodedPath).toString(16) + extensionPart,
       ];
     }
-    return Common.ParsedURL.ParsedURL.join(encodedPathParts as Platform.DevToolsPath.EncodedPathString[], '/');
+    return Common.ParsedURL.ParsedURL.join(encodedPathParts as Platform.DevToolsPath.RawPathString[], '/');
 
-    function encodeUrlPathToLocalPathParts(urlPath: string): string[] {
+    function encodeEncodedPathToLocalPathParts(encodedPath: Platform.DevToolsPath.EncodedPathString): string[] {
       const encodedParts = [];
-      for (const pathPart of fileNamePartsFromUrlPath(urlPath)) {
+      for (const pathPart of fileNamePartsFromEncodedPath(encodedPath)) {
         if (!pathPart) {
           continue;
         }
-        // encodeURI() escapes all the unsafe filename characters except /:?*
-        let encodedName = encodeURI(pathPart).replace(/[\/:\?\*]/g, match => '%' + match[0].charCodeAt(0).toString(16));
-        // Windows does not allow a small set of filenames.
-        if (RESERVED_FILENAMES.has(encodedName.toLowerCase())) {
-          encodedName = encodedName.split('').map(char => '%' + char.charCodeAt(0).toString(16)).join('');
-        }
-        // Windows does not allow the file to end in a space or dot (space should already be encoded).
-        const lastChar = encodedName.charAt(encodedName.length - 1);
-        if (lastChar === '.') {
-          encodedName = encodedName.substr(0, encodedName.length - 1) + '%2e';
+        // encodeURI() escapes all the unsafe filename characters except '/' and '*'
+        let encodedName =
+            encodeURI(pathPart).replace(/[\/\*]/g, match => '%' + match[0].charCodeAt(0).toString(16).toUpperCase());
+        if (Host.Platform.isWin()) {
+          // Windows does not allow ':' and '?' in filenames
+          encodedName = encodedName.replace(/[:\?]/g, match => '%' + match[0].charCodeAt(0).toString(16).toUpperCase());
+          // Windows does not allow a small set of filenames.
+          if (RESERVED_FILENAMES.has(encodedName.toLowerCase())) {
+            encodedName =
+                encodedName.split('').map(char => '%' + char.charCodeAt(0).toString(16).toUpperCase()).join('');
+          }
+          // Windows does not allow the file to end in a space or dot (space should already be encoded).
+          const lastChar = encodedName.charAt(encodedName.length - 1);
+          if (lastChar === '.') {
+            encodedName = encodedName.substr(0, encodedName.length - 1) + '%2E';
+          }
         }
         encodedParts.push(encodedName);
       }
       return encodedParts;
     }
 
-    function fileNamePartsFromUrlPath(urlPath: string): string[] {
-      urlPath = Common.ParsedURL.ParsedURL.urlWithoutHash(urlPath);
-      const queryIndex = urlPath.indexOf('?');
+    function fileNamePartsFromEncodedPath(encodedPath: Platform.DevToolsPath.EncodedPathString): string[] {
+      encodedPath = Common.ParsedURL.ParsedURL.urlWithoutHash(encodedPath) as Platform.DevToolsPath.EncodedPathString;
+      const queryIndex = encodedPath.indexOf('?');
       if (queryIndex === -1) {
-        return urlPath.split('/');
+        return encodedPath.split('/');
       }
       if (queryIndex === 0) {
-        return [urlPath];
+        return [encodedPath];
       }
-      const endSection = urlPath.substr(queryIndex);
-      const parts = urlPath.substr(0, urlPath.length - endSection.length).split('/');
+      const endSection = encodedPath.substr(queryIndex);
+      const parts = encodedPath.substr(0, encodedPath.length - endSection.length).split('/');
       parts[parts.length - 1] += endSection;
       return parts;
     }
   }
 
-  private fileUrlFromNetworkUrl(url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString {
-    return (this.projectInternal as FileSystem).fileSystemPath() + '/' + this.encodedPathFromUrl(url) as
-        Platform.DevToolsPath.UrlString;
+  fileUrlFromNetworkUrl(url: Platform.DevToolsPath.UrlString, ignoreInactive?: boolean):
+      Platform.DevToolsPath.UrlString {
+    if (!this.projectInternal) {
+      return Platform.DevToolsPath.EmptyUrlString;
+    }
+    return Common.ParsedURL.ParsedURL.concatenate(
+        (this.projectInternal as FileSystem).fileSystemPath(), '/', this.encodedPathFromUrl(url, ignoreInactive));
   }
 
   private decodeLocalPathToUrlPath(path: string): string {
@@ -309,16 +328,17 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     const content = (await uiSourceCode.requestContent()).content || '';
     const encoded = await uiSourceCode.contentEncoded();
     const lastIndexOfSlash = encodedPath.lastIndexOf('/');
-    const encodedFileName = encodedPath.substr(lastIndexOfSlash + 1);
+    const encodedFileName = Common.ParsedURL.ParsedURL.substring(encodedPath, lastIndexOfSlash + 1);
+    const rawFileName = Common.ParsedURL.ParsedURL.encodedPathToRawPathString(encodedFileName);
     encodedPath = Common.ParsedURL.ParsedURL.substr(encodedPath, 0, lastIndexOfSlash);
     if (this.projectInternal) {
-      await this.projectInternal.createFile(encodedPath, encodedFileName, content, encoded);
+      await this.projectInternal.createFile(encodedPath, rawFileName, content, encoded);
     }
-    this.fileCreatedForTest(encodedPath, encodedFileName);
+    this.fileCreatedForTest(encodedPath, rawFileName);
     this.savingForOverrides.delete(uiSourceCode);
   }
 
-  private fileCreatedForTest(_path: string, _fileName: string): void {
+  private fileCreatedForTest(_path: Platform.DevToolsPath.EncodedPathString, _fileName: string): void {
   }
 
   private patternForFileSystemUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): string {
@@ -329,7 +349,9 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     if (relativePathParts[1] === 'longurls' && relativePathParts.length !== 2) {
       return 'http?://' + relativePathParts[0] + '/*';
     }
-    return 'http?://' + this.decodeLocalPathToUrlPath(relativePathParts.join('/'));
+    // 'relativePath' returns an encoded string of the local file name which itself is already encoded.
+    // We therefore need to decode twice to get the raw path.
+    return 'http?://' + this.decodeLocalPathToUrlPath(this.decodeLocalPathToUrlPath(relativePathParts.join('/')));
   }
 
   private async onUISourceCodeAdded(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<void> {
@@ -363,14 +385,18 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     this.updateInterceptionPatterns();
 
     const relativePath = FileSystemWorkspaceBinding.relativePath(uiSourceCode);
-    const networkUISourceCode = this.networkUISourceCodeForEncodedPath.get(relativePath.join('/'));
+    const networkUISourceCode =
+        this.networkUISourceCodeForEncodedPath.get(Common.ParsedURL.ParsedURL.join(relativePath, '/'));
     if (networkUISourceCode) {
       await this.bind(networkUISourceCode, uiSourceCode);
     }
   }
 
-  async generateHeaderPatterns(uiSourceCode: Workspace.UISourceCode.UISourceCode):
-      Promise<{headerPatterns: Set<string>, path: string, overridesWithRegex: HeaderOverrideWithRegex[]}> {
+  async generateHeaderPatterns(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<{
+    headerPatterns: Set<string>,
+    path: Platform.DevToolsPath.EncodedPathString,
+    overridesWithRegex: HeaderOverrideWithRegex[],
+  }> {
     const headerPatterns = new Set<string>();
     const content = (await uiSourceCode.requestContent()).content || '[]';
     let headerOverrides: HeaderOverride[] = [];
@@ -381,10 +407,16 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
       }
     } catch (e) {
       console.error('Failed to parse', uiSourceCode.url(), 'for locally overriding headers.');
-      return {headerPatterns, path: '', overridesWithRegex: []};
+      return {headerPatterns, path: Platform.DevToolsPath.EmptyEncodedPathString, overridesWithRegex: []};
     }
     const relativePath = FileSystemWorkspaceBinding.relativePath(uiSourceCode).join('/');
-    const decodedPath = this.decodeLocalPathToUrlPath(relativePath).slice(0, -HEADERS_FILENAME.length);
+    // 'relativePath' returns an encoded string of the local file name which itself is already encoded.
+    // e.g. relativePath: 'www.example.com%253A443/path/.headers '
+    // singlyDecodedPath: 'www.example.com%3A443/path/'
+    // decodedPath: 'www.example.com:443/path'
+    const singlyDecodedPath = this.decodeLocalPathToUrlPath(relativePath).slice(0, -HEADERS_FILENAME.length) as
+        Platform.DevToolsPath.EncodedPathString;
+    const decodedPath = this.decodeLocalPathToUrlPath(singlyDecodedPath) as Platform.DevToolsPath.RawPathString;
 
     const overridesWithRegex: HeaderOverrideWithRegex[] = [];
     for (const headerOverride of headerOverrides) {
@@ -414,7 +446,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
         });
       }
     }
-    return {headerPatterns, path: decodedPath, overridesWithRegex};
+    return {headerPatterns, path: singlyDecodedPath, overridesWithRegex};
   }
 
   async updateInterceptionPatternsForTests(): Promise<void> {
@@ -509,7 +541,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
         FileSystemWorkspaceBinding.fileSystemType(project) !== 'overrides') {
       return;
     }
-    const fileSystemPath = FileSystemWorkspaceBinding.fileSystemPath(project.id());
+    const fileSystemPath = FileSystemWorkspaceBinding.fileSystemPath(project.id() as Platform.DevToolsPath.UrlString);
     if (!fileSystemPath) {
       return;
     }
@@ -542,8 +574,9 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     return result;
   }
 
-  #maybeMergeHeadersForPathSegment(path: string, requestUrl: string, headers: Protocol.Fetch.HeaderEntry[]):
-      Protocol.Fetch.HeaderEntry[] {
+  #maybeMergeHeadersForPathSegment(
+      path: Platform.DevToolsPath.EncodedPathString, requestUrl: Platform.DevToolsPath.UrlString,
+      headers: Protocol.Fetch.HeaderEntry[]): Protocol.Fetch.HeaderEntry[] {
     const headerOverrides = this.#headerOverridesMap.get(path) || [];
     for (const headerOverride of headerOverrides) {
       if (headerOverride.applyToRegex.test(requestUrl)) {
@@ -555,17 +588,22 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
 
   handleHeaderInterception(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Protocol.Fetch.HeaderEntry[] {
     let result: Protocol.Fetch.HeaderEntry[] = interceptedRequest.responseHeaders || [];
+    // 'rawPathFromUrl()''s return value is already (singly-)encoded, so we can
+    // treat it as an 'EncodedPathString' here.
     const urlSegments =
-        this.encodedPathFromUrl(interceptedRequest.request.url as Platform.DevToolsPath.UrlString).split('/');
+        this.rawPathFromUrl(interceptedRequest.request.url as Platform.DevToolsPath.UrlString).split('/') as
+        Platform.DevToolsPath.EncodedPathString[];
     // Traverse the hierarchy of overrides from the most general to the most
     // specific. Check with empty string first to match overrides applying to
     // all domains.
     // e.g. '', 'www.example.com/', 'www.example.com/path/', ...
-    let path = '';
-    result = this.#maybeMergeHeadersForPathSegment(path, interceptedRequest.request.url, result);
+    let path = Platform.DevToolsPath.EmptyEncodedPathString;
+    result = this.#maybeMergeHeadersForPathSegment(
+        path, interceptedRequest.request.url as Platform.DevToolsPath.UrlString, result);
     for (const segment of urlSegments) {
-      path += segment + '/';
-      result = this.#maybeMergeHeadersForPathSegment(path, interceptedRequest.request.url, result);
+      path = Common.ParsedURL.ParsedURL.concatenate(path, segment, '/');
+      result = this.#maybeMergeHeadersForPathSegment(
+          path, interceptedRequest.request.url as Platform.DevToolsPath.UrlString, result);
     }
     return result;
   }
@@ -646,7 +684,7 @@ const RESERVED_FILENAMES = new Set<string>([
   'com8', 'com9', 'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9',
 ]);
 
-const HEADERS_FILENAME = '.headers';
+export const HEADERS_FILENAME = '.headers';
 
 // TODO(crbug.com/1167717): Make this a const enum again
 // eslint-disable-next-line rulesdir/const_enum

package/front_end/models/persistence/PersistenceImpl.ts

@@ -308,7 +308,7 @@ export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     return binding ? binding.network : null;
   }
 
-  filePathHasBindings(filePath: string): boolean {
+  filePathHasBindings(filePath: Platform.DevToolsPath.UrlString): boolean {
     return this.filePathPrefixesToBindingCount.hasBindingPrefix(filePath);
   }
 }
@@ -320,11 +320,11 @@ class FilePathPrefixesBindingCounts {
     this.prefixCounts = new Map();
   }
 
-  private getPlatformCanonicalFilePath(path: string): string {
-    return Host.Platform.isWin() ? path.toLowerCase() : path;
+  private getPlatformCanonicalFilePath(path: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString {
+    return Host.Platform.isWin() ? Common.ParsedURL.ParsedURL.toLowerCase(path) : path;
   }
 
-  add(filePath: string): void {
+  add(filePath: Platform.DevToolsPath.UrlString): void {
     filePath = this.getPlatformCanonicalFilePath(filePath);
     let relative = '';
     for (const token of filePath.split('/')) {
@@ -334,7 +334,7 @@ class FilePathPrefixesBindingCounts {
     }
   }
 
-  remove(filePath: string): void {
+  remove(filePath: Platform.DevToolsPath.UrlString): void {
     filePath = this.getPlatformCanonicalFilePath(filePath);
     let relative = '';
     for (const token of filePath.split('/')) {
@@ -348,10 +348,10 @@ class FilePathPrefixesBindingCounts {
     }
   }
 
-  hasBindingPrefix(filePath: string): boolean {
+  hasBindingPrefix(filePath: Platform.DevToolsPath.UrlString): boolean {
     filePath = this.getPlatformCanonicalFilePath(filePath);
     if (!filePath.endsWith('/')) {
-      filePath += '/';
+      filePath = Common.ParsedURL.ParsedURL.concatenate(filePath, '/');
     }
     return this.prefixCounts.has(filePath);
   }

package/front_end/models/persistence/PlatformFileSystem.ts

@@ -16,9 +16,9 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('models/persistence/PlatformFileSystem.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 export class PlatformFileSystem {
-  private readonly pathInternal: string;
+  private readonly pathInternal: Platform.DevToolsPath.UrlString;
   private readonly typeInternal: string;
-  constructor(path: string, type: string) {
+  constructor(path: Platform.DevToolsPath.UrlString, type: string) {
     this.pathInternal = path;
     this.typeInternal = type;
   }
@@ -36,11 +36,10 @@ export class PlatformFileSystem {
   }
 
   path(): Platform.DevToolsPath.UrlString {
-    // TODO(crbug.com/1297535): Cast to UrlString will be removed when migration to branded types is complete.
-    return this.pathInternal as Platform.DevToolsPath.UrlString;
+    return this.pathInternal;
   }
 
-  embedderPath(): string {
+  embedderPath(): Platform.DevToolsPath.RawPathString {
     throw new Error('Not implemented');
   }
 
@@ -80,7 +79,7 @@ export class PlatformFileSystem {
   addExcludedFolder(_path: Platform.DevToolsPath.EncodedPathString): void {
   }
 
-  removeExcludedFolder(_path: string): void {
+  removeExcludedFolder(_path: Platform.DevToolsPath.EncodedPathString): void {
   }
 
   fileSystemRemoved(): void {
@@ -90,7 +89,7 @@ export class PlatformFileSystem {
     return false;
   }
 
-  excludedFolders(): Set<string> {
+  excludedFolders(): Set<Platform.DevToolsPath.EncodedPathString> {
     return new Set();
   }
 
@@ -104,7 +103,7 @@ export class PlatformFileSystem {
     });
   }
 
-  mimeFromPath(_path: string): string {
+  mimeFromPath(_path: Platform.DevToolsPath.UrlString): string {
     throw new Error('Not implemented');
   }
 

package/front_end/models/persistence/WorkspaceSettingsTab.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as i18n from '../../core/i18n/i18n.js';
+import type * as Platform from '../../core/platform/platform.js';
 import * as UI from '../../ui/legacy/legacy.js';
 
 import {EditFileSystemView} from './EditFileSystemView.js';
@@ -44,8 +45,8 @@ let workspaceSettingsTabInstance: WorkspaceSettingsTab;
 export class WorkspaceSettingsTab extends UI.Widget.VBox {
   containerElement: HTMLElement;
   private readonly fileSystemsListContainer: HTMLElement;
-  private readonly elementByPath: Map<string, Element>;
-  private readonly mappingViewByPath: Map<string, EditFileSystemView>;
+  private readonly elementByPath: Map<Platform.DevToolsPath.UrlString, Element>;
+  private readonly mappingViewByPath: Map<Platform.DevToolsPath.UrlString, EditFileSystemView>;
   private constructor() {
     super();