chrome-devtools-frontend 1.0.980193 → 1.0.981004

package/front_end/models/persistence/IsolatedFileSystem.ts

@@ -70,17 +70,19 @@ const str_ = i18n.i18n.registerUIStrings('models/persistence/IsolatedFileSystem.
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 export class IsolatedFileSystem extends PlatformFileSystem {
   private readonly manager: IsolatedFileSystemManager;
-  private readonly embedderPathInternal: string;
+  private readonly embedderPathInternal: Platform.DevToolsPath.RawPathString;
   private readonly domFileSystem: FileSystem;
-  private readonly excludedFoldersSetting: Common.Settings.Setting<{[path: string]: string[]}>;
-  private excludedFoldersInternal: Set<string>;
-  private readonly excludedEmbedderFolders: string[];
+  private readonly excludedFoldersSetting:
+      Common.Settings.Setting<{[path: Platform.DevToolsPath.UrlString]: Platform.DevToolsPath.EncodedPathString[]}>;
+  private excludedFoldersInternal: Set<Platform.DevToolsPath.EncodedPathString>;
+  private readonly excludedEmbedderFolders: Platform.DevToolsPath.RawPathString[];
   private readonly initialFilePathsInternal: Set<Platform.DevToolsPath.EncodedPathString>;
   private readonly initialGitFoldersInternal: Set<Platform.DevToolsPath.EncodedPathString>;
-  private readonly fileLocks: Map<string, Promise<void>>;
+  private readonly fileLocks: Map<Platform.DevToolsPath.EncodedPathString, Promise<void>>;
 
   constructor(
-      manager: IsolatedFileSystemManager, path: string, embedderPath: string, domFileSystem: FileSystem, type: string) {
+      manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
+      embedderPath: Platform.DevToolsPath.RawPathString, domFileSystem: FileSystem, type: string) {
     super(path, type);
     this.manager = manager;
     this.embedderPathInternal = embedderPath;
@@ -96,7 +98,8 @@ export class IsolatedFileSystem extends PlatformFileSystem {
   }
 
   static async create(
-      manager: IsolatedFileSystemManager, path: string, embedderPath: string, type: string, name: string,
+      manager: IsolatedFileSystemManager, path: Platform.DevToolsPath.UrlString,
+      embedderPath: Platform.DevToolsPath.RawPathString, type: string, name: string,
       rootURL: string): Promise<IsolatedFileSystem|null> {
     const domFileSystem = Host.InspectorFrontendHost.InspectorFrontendHostInstance.isolatedFileSystem(name, rootURL);
     if (!domFileSystem) {
@@ -115,18 +118,20 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return i18nString(UIStrings.fileSystemErrorS, {PH1: error.message});
   }
 
-  private serializedFileOperation<T>(path: string, operation: () => Promise<T>): Promise<T> {
+  private serializedFileOperation<T>(path: Platform.DevToolsPath.EncodedPathString, operation: () => Promise<T>):
+      Promise<T> {
     const promise = Promise.resolve(this.fileLocks.get(path)).then(() => operation.call(null));
     this.fileLocks.set(path, promise as unknown as Promise<void>);
     return promise;
   }
 
-  getMetadata(path: string): Promise<Metadata|null> {
+  getMetadata(path: Platform.DevToolsPath.EncodedPathString): Promise<Metadata|null> {
     let fulfill: (arg0: Metadata|null) => void;
     const promise = new Promise<Metadata|null>(f => {
       fulfill = f;
     });
-    this.domFileSystem.root.getFile(decodeURIComponent(path), undefined, fileEntryLoaded, errorHandler);
+    this.domFileSystem.root.getFile(
+        Common.ParsedURL.ParsedURL.encodedPathToRawPathString(path), undefined, fileEntryLoaded, errorHandler);
     return promise;
 
     function fileEntryLoaded(entry: FileEntry): void {
@@ -148,7 +153,7 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return [...this.initialGitFoldersInternal];
   }
 
-  embedderPath(): string {
+  embedderPath(): Platform.DevToolsPath.RawPathString {
     return this.embedderPathInternal;
   }
 
@@ -156,13 +161,14 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return new Promise(fulfill => {
       let pendingRequests = 1;
       const boundInnerCallback = innerCallback.bind(this);
-      this.requestEntries('', boundInnerCallback);
+      this.requestEntries(Platform.DevToolsPath.EmptyRawPathString, boundInnerCallback);
 
       function innerCallback(this: IsolatedFileSystem, entries: FileEntry[]): void {
         for (let i = 0; i < entries.length; ++i) {
           const entry = entries[i];
           if (!entry.isDirectory) {
-            if (this.isFileExcluded(entry.fullPath)) {
+            if (this.isFileExcluded(Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(
+                    entry.fullPath as Platform.DevToolsPath.RawPathString))) {
               continue;
             }
             this.initialFilePathsInternal.add(Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(
@@ -174,14 +180,20 @@ export class IsolatedFileSystem extends PlatformFileSystem {
                   entry.fullPath as Platform.DevToolsPath.RawPathString, 1, lastSlash);
               this.initialGitFoldersInternal.add(Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(parentFolder));
             }
-            if (this.isFileExcluded(entry.fullPath + '/')) {
-              const url = Common.ParsedURL.ParsedURL.concatenate(this.path(), entry.fullPath);
+            if (this.isFileExcluded(Common.ParsedURL.ParsedURL.concatenate(
+                    Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(
+                        entry.fullPath as Platform.DevToolsPath.RawPathString),
+                    '/'))) {
+              const url = Common.ParsedURL.ParsedURL.concatenate(
+                  this.path(),
+                  Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(
+                      entry.fullPath as Platform.DevToolsPath.RawPathString));
               this.excludedEmbedderFolders.push(
                   Common.ParsedURL.ParsedURL.urlToRawPathString(url, Host.Platform.isWin()));
               continue;
             }
             ++pendingRequests;
-            this.requestEntries(entry.fullPath, boundInnerCallback);
+            this.requestEntries(entry.fullPath as Platform.DevToolsPath.RawPathString, boundInnerCallback);
           }
         }
         if ((--pendingRequests === 0)) {
@@ -191,7 +203,7 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     });
   }
 
-  private async createFoldersIfNotExist(folderPath: string): Promise<DirectoryEntry|null> {
+  private async createFoldersIfNotExist(folderPath: Platform.DevToolsPath.RawPathString): Promise<DirectoryEntry|null> {
     // Fast-path. If parent directory already exists we return it immidiatly.
     let dirEntry = await new Promise<DirectoryEntry|null>(
         resolve => this.domFileSystem.root.getDirectory(folderPath, undefined, resolve, () => resolve(null)));
@@ -220,13 +232,17 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     });
   }
 
-  async createFile(path: string, name: string|null): Promise<string|null> {
-    const dirEntry = await this.createFoldersIfNotExist(decodeURIComponent(path));
+  async createFile(path: Platform.DevToolsPath.EncodedPathString, name: Platform.DevToolsPath.RawPathString|null):
+      Promise<Platform.DevToolsPath.EncodedPathString|null> {
+    const dirEntry = await this.createFoldersIfNotExist(Common.ParsedURL.ParsedURL.encodedPathToRawPathString(path));
     if (!dirEntry) {
       return null;
     }
     const fileEntry =
-        await this.serializedFileOperation(path, createFileCandidate.bind(this, name || 'NewFile')) as FileEntry | null;
+        await this.serializedFileOperation(
+            path, createFileCandidate.bind(this, name || 'NewFile' as Platform.DevToolsPath.RawPathString)) as
+            FileEntry |
+        null;
     if (!fileEntry) {
       return null;
     }
@@ -234,9 +250,10 @@ export class IsolatedFileSystem extends PlatformFileSystem {
         Common.ParsedURL.ParsedURL.substr(fileEntry.fullPath as Platform.DevToolsPath.RawPathString, 1));
 
     function createFileCandidate(
-        this: IsolatedFileSystem, name: string, newFileIndex?: number): Promise<FileEntry|null> {
+        this: IsolatedFileSystem, name: Platform.DevToolsPath.RawPathString,
+        newFileIndex?: number): Promise<FileEntry|null> {
       return new Promise(resolve => {
-        const nameCandidate = name + (newFileIndex || '');
+        const nameCandidate = Common.ParsedURL.ParsedURL.concatenate(name, (newFileIndex || '').toString());
         (dirEntry as DirectoryEntry).getFile(nameCandidate, {create: true, exclusive: true}, resolve, error => {
           if (error.name === 'InvalidModificationError') {
             resolve(createFileCandidate.call(this, name, (newFileIndex ? newFileIndex + 1 : 1)));
@@ -252,13 +269,14 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     }
   }
 
-  deleteFile(path: string): Promise<boolean> {
+  deleteFile(path: Platform.DevToolsPath.EncodedPathString): Promise<boolean> {
     let resolveCallback: (arg0: boolean) => void;
     const promise = new Promise<boolean>(resolve => {
       resolveCallback = resolve;
     });
     this.domFileSystem.root.getFile(
-        decodeURIComponent(path), undefined, fileEntryLoaded.bind(this), errorHandler.bind(this));
+        Common.ParsedURL.ParsedURL.encodedPathToRawPathString(path), undefined, fileEntryLoaded.bind(this),
+        errorHandler.bind(this));
     return promise;
 
     function fileEntryLoaded(this: IsolatedFileSystem, fileEntry: FileEntry): void {
@@ -279,9 +297,9 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     }
   }
 
-  requestFileBlob(path: string): Promise<Blob|null> {
+  requestFileBlob(path: Platform.DevToolsPath.EncodedPathString): Promise<Blob|null> {
     return new Promise(resolve => {
-      this.domFileSystem.root.getFile(decodeURIComponent(path), undefined, entry => {
+      this.domFileSystem.root.getFile(Common.ParsedURL.ParsedURL.encodedPathToRawPathString(path), undefined, entry => {
         entry.file(resolve, errorHandler.bind(this));
       }, errorHandler.bind(this));
 
@@ -298,11 +316,13 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     });
   }
 
-  requestFileContent(path: string): Promise<TextUtils.ContentProvider.DeferredContent> {
+  requestFileContent(path: Platform.DevToolsPath.EncodedPathString):
+      Promise<TextUtils.ContentProvider.DeferredContent> {
     return this.serializedFileOperation(path, () => this.innerRequestFileContent(path));
   }
 
-  private async innerRequestFileContent(path: string): Promise<TextUtils.ContentProvider.DeferredContent> {
+  private async innerRequestFileContent(path: Platform.DevToolsPath.EncodedPathString):
+      Promise<TextUtils.ContentProvider.DeferredContent> {
     const blob = await this.requestFileBlob(path);
     if (!blob) {
       return {content: null, error: i18nString(UIStrings.blobCouldNotBeLoaded), isEncoded: false};
@@ -341,7 +361,8 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return {isEncoded: encoded, content: encoded ? btoa(result) : result};
   }
 
-  async setFileContent(path: string, content: string, isBase64: boolean): Promise<void> {
+  async setFileContent(path: Platform.DevToolsPath.EncodedPathString, content: string, isBase64: boolean):
+      Promise<void> {
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.FileSavedInWorkspace);
     let callback: (event?: ProgressEvent<EventTarget>) => void;
     const innerSetFileContent = (): Promise<ProgressEvent<EventTarget>> => {
@@ -350,7 +371,8 @@ export class IsolatedFileSystem extends PlatformFileSystem {
         callback = x;
       });
       this.domFileSystem.root.getFile(
-          decodeURIComponent(path), {create: true}, fileEntryLoaded.bind(this), errorHandler.bind(this));
+          Common.ParsedURL.ParsedURL.encodedPathToRawPathString(path), {create: true}, fileEntryLoaded.bind(this),
+          errorHandler.bind(this));
       return promise;
     };
 
@@ -385,8 +407,10 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     }
   }
 
-  renameFile(path: string, newName: string, callback: (arg0: boolean, arg1?: string|undefined) => void): void {
-    newName = newName ? newName.trim() : newName;
+  renameFile(
+      path: Platform.DevToolsPath.EncodedPathString, newName: Platform.DevToolsPath.RawPathString,
+      callback: (arg0: boolean, arg1?: string|undefined) => void): void {
+    newName = newName ? Common.ParsedURL.ParsedURL.trim(newName) : newName;
     if (!newName || newName.indexOf('/') !== -1) {
       callback(false);
       return;
@@ -395,7 +419,8 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     let dirEntry: DirectoryEntry;
 
     this.domFileSystem.root.getFile(
-        decodeURIComponent(path), undefined, fileEntryLoaded.bind(this), errorHandler.bind(this));
+        Common.ParsedURL.ParsedURL.encodedPathToRawPathString(path), undefined, fileEntryLoaded.bind(this),
+        errorHandler.bind(this));
 
     function fileEntryLoaded(this: IsolatedFileSystem, entry: FileEntry): void {
       if (entry.name === newName) {
@@ -461,8 +486,8 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     }
   }
 
-  private requestEntries(path: string, callback: (arg0: Array<FileEntry>) => void): void {
-    this.domFileSystem.root.getDirectory(decodeURIComponent(path), undefined, innerCallback.bind(this), errorHandler);
+  private requestEntries(path: Platform.DevToolsPath.RawPathString, callback: (arg0: Array<FileEntry>) => void): void {
+    this.domFileSystem.root.getDirectory(path, undefined, innerCallback.bind(this), errorHandler);
 
     function innerCallback(this: IsolatedFileSystem, dirEntry: DirectoryEntry): void {
       this.readDirectory(dirEntry, callback);
@@ -481,13 +506,13 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     this.excludedFoldersSetting.set(settingValue);
   }
 
-  addExcludedFolder(path: string): void {
+  addExcludedFolder(path: Platform.DevToolsPath.EncodedPathString): void {
     this.excludedFoldersInternal.add(path);
     this.saveExcludedFolders();
     this.manager.dispatchEventToListeners(Events.ExcludedFolderAdded, path);
   }
 
-  removeExcludedFolder(path: string): void {
+  removeExcludedFolder(path: Platform.DevToolsPath.EncodedPathString): void {
     this.excludedFoldersInternal.delete(path);
     this.saveExcludedFolders();
     this.manager.dispatchEventToListeners(Events.ExcludedFolderRemoved, path);
@@ -499,12 +524,12 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     this.excludedFoldersSetting.set(settingValue);
   }
 
-  isFileExcluded(folderPath: string): boolean {
+  isFileExcluded(folderPath: Platform.DevToolsPath.EncodedPathString): boolean {
     if (this.excludedFoldersInternal.has(folderPath)) {
       return true;
     }
     const regex = (this.manager.workspaceFolderExcludePatternSetting() as Common.Settings.RegExpSetting).asRegExp();
-    return Boolean(regex && regex.test(folderPath));
+    return Boolean(regex && regex.test(Common.ParsedURL.ParsedURL.encodedPathToRawPathString(folderPath)));
   }
 
   excludedFolders(): Set<string> {
@@ -535,10 +560,11 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return Common.ResourceType.ResourceType.mimeFromURL(path) || 'text/plain';
   }
 
-  canExcludeFolder(path: string): boolean {
+  canExcludeFolder(path: Platform.DevToolsPath.EncodedPathString): boolean {
     return Boolean(path) && this.type() !== 'overrides';
   }
 
+  // path not typed as Branded Types as here we are interested in extention only
   contentType(path: string): Common.ResourceType.ResourceType {
     const extension = Common.ParsedURL.ParsedURL.extractExtension(path);
     if (STYLE_SHEET_EXTENSIONS.has(extension)) {

package/front_end/models/persistence/IsolatedFileSystemManager.ts

@@ -248,7 +248,8 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
         const filePath = Common.ParsedURL.ParsedURL.rawPathToUrlString(embedderPath);
         for (const fileSystemPath of this.fileSystemsInternal.keys()) {
           const fileSystem = this.fileSystemsInternal.get(fileSystemPath);
-          if (fileSystem && fileSystem.isFileExcluded(embedderPath)) {
+          if (fileSystem &&
+              fileSystem.isFileExcluded(Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(embedderPath))) {
             continue;
           }
           const pathPrefix = fileSystemPath.endsWith('/') ? fileSystemPath : fileSystemPath + '/';
@@ -348,8 +349,8 @@ export type EventTypes = {
   [Events.FileSystemAdded]: PlatformFileSystem,
   [Events.FileSystemRemoved]: PlatformFileSystem,
   [Events.FileSystemFilesChanged]: FilesChangedData,
-  [Events.ExcludedFolderAdded]: string,
-  [Events.ExcludedFolderRemoved]: string,
+  [Events.ExcludedFolderAdded]: Platform.DevToolsPath.EncodedPathString,
+  [Events.ExcludedFolderRemoved]: Platform.DevToolsPath.EncodedPathString,
 };
 
 let lastRequestId = 0;

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -185,9 +185,9 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     PersistenceImpl.instance().refreshAutomapping();
   }
 
-  private encodedPathFromUrl(url: string): string {
+  private encodedPathFromUrl(url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.EncodedPathString {
     if (!this.activeInternal || !this.projectInternal) {
-      return '';
+      return Platform.DevToolsPath.EmptyEncodedPathString;
     }
     let urlPath = Common.ParsedURL.ParsedURL.urlWithoutHash(url.replace(/^https?:\/\//, ''));
     if (urlPath.endsWith('/') && urlPath.indexOf('?') === -1) {
@@ -208,7 +208,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
         shortFileName + Platform.StringUtilities.hashCode(encodedPath).toString(16) + extensionPart,
       ];
     }
-    return encodedPathParts.join('/');
+    return Common.ParsedURL.ParsedURL.join(encodedPathParts as Platform.DevToolsPath.EncodedPathString[], '/');
 
     function encodeUrlPathToLocalPathParts(urlPath: string): string[] {
       const encodedParts = [];
@@ -310,7 +310,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     const encoded = await uiSourceCode.contentEncoded();
     const lastIndexOfSlash = encodedPath.lastIndexOf('/');
     const encodedFileName = encodedPath.substr(lastIndexOfSlash + 1);
-    encodedPath = encodedPath.substr(0, lastIndexOfSlash);
+    encodedPath = Common.ParsedURL.ParsedURL.substr(encodedPath, 0, lastIndexOfSlash);
     if (this.projectInternal) {
       await this.projectInternal.createFile(encodedPath, encodedFileName, content, encoded);
     }
@@ -555,7 +555,8 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
 
   handleHeaderInterception(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Protocol.Fetch.HeaderEntry[] {
     let result: Protocol.Fetch.HeaderEntry[] = interceptedRequest.responseHeaders || [];
-    const urlSegments = this.encodedPathFromUrl(interceptedRequest.request.url).split('/');
+    const urlSegments =
+        this.encodedPathFromUrl(interceptedRequest.request.url as Platform.DevToolsPath.UrlString).split('/');
     // 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.

package/front_end/models/persistence/PlatformFileSystem.ts

@@ -23,7 +23,7 @@ export class PlatformFileSystem {
     this.typeInternal = type;
   }
 
-  getMetadata(_path: string): Promise<{modificationTime: Date, size: number}|null> {
+  getMetadata(_path: Platform.DevToolsPath.EncodedPathString): Promise<{modificationTime: Date, size: number}|null> {
     return Promise.resolve(null);
   }
 
@@ -36,6 +36,7 @@ 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;
   }
 
@@ -48,31 +49,35 @@ export class PlatformFileSystem {
     return this.typeInternal;
   }
 
-  async createFile(_path: string, _name: string|null): Promise<string|null> {
+  async createFile(_path: Platform.DevToolsPath.EncodedPathString, _name: Platform.DevToolsPath.RawPathString|null):
+      Promise<Platform.DevToolsPath.EncodedPathString|null> {
     return Promise.resolve(null);
   }
 
-  deleteFile(_path: string): Promise<boolean> {
+  deleteFile(_path: Platform.DevToolsPath.EncodedPathString): Promise<boolean> {
     return Promise.resolve(false);
   }
 
-  requestFileBlob(_path: string): Promise<Blob|null> {
+  requestFileBlob(_path: Platform.DevToolsPath.EncodedPathString): Promise<Blob|null> {
     return Promise.resolve(null as Blob | null);
   }
 
-  async requestFileContent(_path: string): Promise<TextUtils.ContentProvider.DeferredContent> {
+  async requestFileContent(_path: Platform.DevToolsPath.EncodedPathString):
+      Promise<TextUtils.ContentProvider.DeferredContent> {
     return {content: null, error: i18nString(UIStrings.unableToReadFilesWithThis), isEncoded: false};
   }
 
-  setFileContent(_path: string, _content: string, _isBase64: boolean): void {
+  setFileContent(_path: Platform.DevToolsPath.EncodedPathString, _content: string, _isBase64: boolean): void {
     throw new Error('Not implemented');
   }
 
-  renameFile(_path: string, _newName: string, callback: (arg0: boolean, arg1?: string|undefined) => void): void {
+  renameFile(
+      _path: Platform.DevToolsPath.EncodedPathString, _newName: Platform.DevToolsPath.RawPathString,
+      callback: (arg0: boolean, arg1?: string|undefined) => void): void {
     callback(false);
   }
 
-  addExcludedFolder(_path: string): void {
+  addExcludedFolder(_path: Platform.DevToolsPath.EncodedPathString): void {
   }
 
   removeExcludedFolder(_path: string): void {
@@ -81,7 +86,7 @@ export class PlatformFileSystem {
   fileSystemRemoved(): void {
   }
 
-  isFileExcluded(_folderPath: string): boolean {
+  isFileExcluded(_folderPath: Platform.DevToolsPath.EncodedPathString): boolean {
     return false;
   }
 
@@ -103,7 +108,7 @@ export class PlatformFileSystem {
     throw new Error('Not implemented');
   }
 
-  canExcludeFolder(_path: string): boolean {
+  canExcludeFolder(_path: Platform.DevToolsPath.EncodedPathString): boolean {
     return false;
   }
 

package/front_end/models/workspace/UISourceCode.ts

@@ -51,6 +51,8 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('models/workspace/UISourceCode.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
+// TODO(crbug.com/1297535): Casts to UrlString and RawPathString will be removed from this file when migration to branded types is complete.
+
 export class UISourceCode extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     TextUtils.ContentProvider.ContentProvider {
   private projectInternal: Project;
@@ -92,7 +94,7 @@ export class UISourceCode extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       }
     } else {
       this.originInternal = '';
-      this.parentURLInternal = '' as Platform.DevToolsPath.UrlString;
+      this.parentURLInternal = Platform.DevToolsPath.EmptyUrlString;
       this.nameInternal = url;
     }
 
@@ -150,7 +152,7 @@ export class UISourceCode extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     return this.projectInternal.canRename();
   }
 
-  rename(newName: string): Promise<boolean> {
+  rename(newName: Platform.DevToolsPath.RawPathString): Promise<boolean> {
     let fulfill: (arg0: boolean) => void;
     const promise = new Promise<boolean>(x => {
       fulfill = x;

package/front_end/models/workspace/WorkspaceImpl.ts

@@ -29,6 +29,7 @@
  */
 
 import * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
 import type * as TextUtils from '../text_utils/text_utils.js';
 
 import type {UISourceCodeMetadata} from './UISourceCode.js';
@@ -56,11 +57,12 @@ export interface Project {
   mimeType(uiSourceCode: UISourceCode): string;
   canRename(): boolean;
   rename(
-      uiSourceCode: UISourceCode, newName: string,
+      uiSourceCode: UISourceCode, newName: Platform.DevToolsPath.RawPathString,
       callback: (arg0: boolean, arg1?: string, arg2?: string, arg3?: Common.ResourceType.ResourceType) => void): void;
   excludeFolder(path: string): void;
-  canExcludeFolder(path: string): boolean;
-  createFile(path: string, name: string|null, content: string, isBase64?: boolean): Promise<UISourceCode|null>;
+  canExcludeFolder(path: Platform.DevToolsPath.EncodedPathString): boolean;
+  createFile(path: Platform.DevToolsPath.EncodedPathString, name: string|null, content: string, isBase64?: boolean):
+      Promise<UISourceCode|null>;
   canCreateFile(): boolean;
   deleteFile(uiSourceCode: UISourceCode): void;
   remove(): void;
@@ -209,8 +211,10 @@ export abstract class ProjectStore implements Project {
   abstract fullDisplayName(uiSourceCode: UISourceCode): string;
   abstract mimeType(uiSourceCode: UISourceCode): string;
   abstract canRename(): boolean;
-  abstract canExcludeFolder(path: string): boolean;
-  abstract createFile(path: string, name: string|null, content: string, isBase64?: boolean): Promise<UISourceCode|null>;
+  abstract canExcludeFolder(path: Platform.DevToolsPath.EncodedPathString): boolean;
+  abstract createFile(
+      path: Platform.DevToolsPath.EncodedPathString, name: string|null, content: string,
+      isBase64?: boolean): Promise<UISourceCode|null>;
   abstract canCreateFile(): boolean;
   abstract searchInFileContent(uiSourceCode: UISourceCode, query: string, caseSensitive: boolean, isRegex: boolean):
       Promise<TextUtils.ContentProvider.SearchMatch[]>;

package/front_end/panels/application/ServiceWorkerCacheViews.ts

@@ -382,7 +382,7 @@ export class ServiceWorkerCacheView extends UI.View.SimpleView {
   private createRequest(entry: Protocol.CacheStorage.DataEntry): SDK.NetworkRequest.NetworkRequest {
     const request = SDK.NetworkRequest.NetworkRequest.createWithoutBackendRequest(
         'cache-storage-' + entry.requestURL, entry.requestURL as Platform.DevToolsPath.UrlString,
-        '' as Platform.DevToolsPath.UrlString, null);
+        Platform.DevToolsPath.EmptyUrlString, null);
     request.requestMethod = entry.requestMethod;
     request.setRequestHeaders(entry.requestHeaders);
     request.statusCode = entry.responseStatus;

package/front_end/panels/network/ResourceWebSocketFrameView.ts

@@ -462,8 +462,7 @@ export class ResourceWebSocketFrameNode extends DataGrid.SortableDataGrid.Sortab
     if (!this.binaryViewInternal) {
       if (this.dataTextInternal.length > 0) {
         this.binaryViewInternal = new BinaryResourceView(
-            this.dataTextInternal, /* url */ '' as Platform.DevToolsPath.UrlString,
-            Common.ResourceType.resourceTypes.WebSocket);
+            this.dataTextInternal, Platform.DevToolsPath.EmptyUrlString, Common.ResourceType.resourceTypes.WebSocket);
       }
     }
     return this.binaryViewInternal;

package/front_end/panels/snippets/ScriptSnippetFileSystem.ts

@@ -13,8 +13,6 @@ import type * as TextUtils from '../../models/text_utils/text_utils.js';
 import * as UI from '../../ui/legacy/legacy.js';
 import * as Workspace from '../../models/workspace/workspace.js';
 
-// TODO(crbug.com/1253323): Cast to EncodedPathString will be removed from this file when migration to branded types is complete.
-
 const UIStrings = {
   /**
   *@description Default snippet name when a new snippet is created in the Sources panel
@@ -30,12 +28,12 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('panels/snippets/ScriptSnippetFileSystem.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
-function escapeSnippetName(name: string): Platform.DevToolsPath.EncodedPathString {
-  return Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(name as Platform.DevToolsPath.RawPathString);
+function escapeSnippetName(name: Platform.DevToolsPath.RawPathString): Platform.DevToolsPath.EncodedPathString {
+  return Common.ParsedURL.ParsedURL.rawPathToEncodedPathString(name);
 }
 
-function unescapeSnippetName(name: string): string {
-  return Common.ParsedURL.ParsedURL.encodedPathToRawPathString(name as Platform.DevToolsPath.EncodedPathString);
+function unescapeSnippetName(name: Platform.DevToolsPath.EncodedPathString): string {
+  return Common.ParsedURL.ParsedURL.encodedPathToRawPathString(name);
 }
 
 export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFileSystem {
@@ -53,11 +51,13 @@ export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFi
     return savedSnippets.map(snippet => escapeSnippetName(snippet.name));
   }
 
-  async createFile(_path: string, _name: string|null): Promise<string|null> {
+  async createFile(_path: Platform.DevToolsPath.EncodedPathString, _name: Platform.DevToolsPath.RawPathString|null):
+      Promise<Platform.DevToolsPath.EncodedPathString|null> {
     const nextId = this.lastSnippetIdentifierSetting.get() + 1;
     this.lastSnippetIdentifierSetting.set(nextId);
 
-    const snippetName = i18nString(UIStrings.scriptSnippet, {PH1: nextId});
+    const snippetName =
+        i18nString(UIStrings.scriptSnippet, {PH1: nextId}) as string as Platform.DevToolsPath.RawPathString;
     const snippets = this.snippetsSetting.get();
     snippets.push({name: snippetName, content: ''});
     this.snippetsSetting.set(snippets);
@@ -65,8 +65,8 @@ export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFi
     return escapeSnippetName(snippetName);
   }
 
-  async deleteFile(path: string): Promise<boolean> {
-    const name = unescapeSnippetName(path.substring(1));
+  async deleteFile(path: Platform.DevToolsPath.EncodedPathString): Promise<boolean> {
+    const name = unescapeSnippetName(Common.ParsedURL.ParsedURL.substring(path, 1));
     const allSnippets: Snippet[] = this.snippetsSetting.get();
     const snippets = allSnippets.filter(snippet => snippet.name !== name);
     if (allSnippets.length !== snippets.length) {
@@ -76,8 +76,9 @@ export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFi
     return false;
   }
 
-  async requestFileContent(path: string): Promise<TextUtils.ContentProvider.DeferredContent> {
-    const name = unescapeSnippetName(path.substring(1));
+  async requestFileContent(path: Platform.DevToolsPath.EncodedPathString):
+      Promise<TextUtils.ContentProvider.DeferredContent> {
+    const name = unescapeSnippetName(Common.ParsedURL.ParsedURL.substring(path, 1));
     const snippets: Snippet[] = this.snippetsSetting.get();
     const snippet = snippets.find(snippet => snippet.name === name);
     if (snippet) {
@@ -86,8 +87,9 @@ export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFi
     return {content: null, isEncoded: false, error: `A snippet with name '${name}' was not found`};
   }
 
-  async setFileContent(path: string, content: string, _isBase64: boolean): Promise<boolean> {
-    const name = unescapeSnippetName(path.substring(1));
+  async setFileContent(path: Platform.DevToolsPath.EncodedPathString, content: string, _isBase64: boolean):
+      Promise<boolean> {
+    const name = unescapeSnippetName(Common.ParsedURL.ParsedURL.substring(path, 1));
     const snippets: Snippet[] = this.snippetsSetting.get();
     const snippet = snippets.find(snippet => snippet.name === name);
     if (snippet) {
@@ -98,11 +100,13 @@ export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFi
     return false;
   }
 
-  renameFile(path: string, newName: string, callback: (arg0: boolean, arg1?: string|undefined) => void): void {
-    const name = unescapeSnippetName(path.substring(1));
+  renameFile(
+      path: Platform.DevToolsPath.EncodedPathString, newName: Platform.DevToolsPath.RawPathString,
+      callback: (arg0: boolean, arg1?: string|undefined) => void): void {
+    const name = unescapeSnippetName(Common.ParsedURL.ParsedURL.substring(path, 1));
     const snippets: Snippet[] = this.snippetsSetting.get();
     const snippet = snippets.find(snippet => snippet.name === name);
-    newName = newName.trim();
+    newName = Common.ParsedURL.ParsedURL.trim(newName);
     if (!snippet || newName.length === 0 || snippets.find(snippet => snippet.name === newName)) {
       callback(false);
       return;
@@ -128,7 +132,9 @@ export class SnippetFileSystem extends Persistence.PlatformFileSystem.PlatformFi
   }
 
   tooltipForURL(url: Platform.DevToolsPath.UrlString): string {
-    return i18nString(UIStrings.linkedTo, {PH1: unescapeSnippetName(url.substring(this.path().length))});
+    return i18nString(
+        UIStrings.linkedTo,
+        {PH1: unescapeSnippetName(Common.ParsedURL.ParsedURL.sliceUrlToEncodedPathString(url, this.path().length))});
   }
 
   supportsAutomapping(): boolean {
@@ -215,6 +221,6 @@ export function findSnippetsProject(): Workspace.Workspace.Project {
   return workspaceProject;
 }
 export interface Snippet {
-  name: string;
+  name: Platform.DevToolsPath.RawPathString;
   content: string;
 }