[persistence] Introduce initial AutomaticFileSystemManager.

This adds a new singleton `AutomaticFileSystemManager` whose
functionality is gated behind the `DevToolsAutomaticFileSystems` feature
flag, which attempts to automatically connect workspace folders based on
project settings.

This CL doesn't provide any means in terms of UI in which the user could
trigger a first-time setup of an automatic file system. That will land
in a follow-up CL.

Bug: 395562934
Change-Id: I033b081e6859a04d47462ed916dd6de8edae5be8
Doc: http://go/chrome-devtools:automatic-workspace-folders-design
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6276943
Auto-Submit: Benedikt Meurer <[email protected]>
Reviewed-by: Alex Rudenko <[email protected]>
Commit-Queue: Benedikt Meurer <[email protected]>

Author: bmeurer

config/gni/devtools_grd_files.gni

@@ -1056,6 +1056,7 @@ grd_files_debug_sources = [
   "front_end/models/logs/NetworkLog.js",
   "front_end/models/logs/RequestResolver.js",
   "front_end/models/persistence/Automapping.js",
+  "front_end/models/persistence/AutomaticFileSystemManager.js",
   "front_end/models/persistence/EditFileSystemView.js",
   "front_end/models/persistence/FileSystemWorkspaceBinding.js",
   "front_end/models/persistence/IsolatedFileSystem.js",

front_end/core/host/InspectorFrontendHost.ts

@@ -271,6 +271,18 @@ export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
   recordUserMetricsAction(umaName: string): void {
   }
 
+  connectAutomaticFileSystem(
+      _fileSystemPath: Platform.DevToolsPath.RawPathString,
+      _fileSystemUUID: string,
+      _addIfMissing: boolean,
+      callback: (result: {success: boolean}) => void,
+      ): void {
+    queueMicrotask(() => callback({success: false}));
+  }
+
+  disconnectAutomaticFileSystem(fileSystemPath: Platform.DevToolsPath.RawPathString): void {
+  }
+
   requestFileSystems(): void {
     this.events.dispatchEventToListeners(Events.FileSystemsLoaded, []);
   }

front_end/core/host/InspectorFrontendHostAPI.ts

@@ -236,6 +236,15 @@ export interface EventTypes {
 }
 
 export interface InspectorFrontendHostAPI {
+  connectAutomaticFileSystem(
+      fileSystemPath: Platform.DevToolsPath.RawPathString,
+      fileSystemUUID: string,
+      addIfMissing: boolean,
+      callback: (result: {success: boolean}) => void,
+      ): void;
+
+  disconnectAutomaticFileSystem(fileSystemPath: Platform.DevToolsPath.RawPathString): void;
+
   addFileSystem(type?: string): void;
 
   loadCompleted(): void;

front_end/devtools_compatibility.js

@@ -802,6 +802,28 @@ const InspectorFrontendHostImpl = class {
     DevToolsAPI.sendMessageToEmbedder('recordUserMetricsAction', [umaName], null);
   }
 
+  /**
+   * @override
+   */
+  connectAutomaticFileSystem(fileSystemPath, fileSystemUUID, addIfMissing, callback) {
+    DevToolsAPI.sendMessageToEmbedder(
+        'connectAutomaticFileSystem',
+        [fileSystemPath, fileSystemUUID, addIfMissing],
+        callback,
+    );
+  }
+
+  /**
+   * @override
+   */
+  disconnectAutomaticFileSystem(fileSystemPath) {
+    DevToolsAPI.sendMessageToEmbedder(
+        'disconnectAutomaticFileSystem',
+        [fileSystemPath],
+        null,
+    );
+  }
+
   /**
    * @override
    */

front_end/entrypoints/main/MainImpl.ts

@@ -527,13 +527,20 @@ export class MainImpl {
       debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance(),
     });
 
-    ProjectSettings.ProjectSettingsModel.ProjectSettingsModel.instance({
+    const projectSettingsModel = ProjectSettings.ProjectSettingsModel.ProjectSettingsModel.instance({
       forceNew: true,
       hostConfig: Root.Runtime.hostConfig,
       pageResourceLoader: SDK.PageResourceLoader.PageResourceLoader.instance(),
       targetManager,
     });
 
+    Persistence.AutomaticFileSystemManager.AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig: Root.Runtime.hostConfig,
+      inspectorFrontendHost: Host.InspectorFrontendHost.InspectorFrontendHostInstance,
+      projectSettingsModel,
+    });
+
     AutofillManager.AutofillManager.AutofillManager.instance();
 
     LiveMetrics.LiveMetrics.instance();

front_end/models/persistence/AutomaticFileSystemManager.test.ts

@@ -0,0 +1,156 @@
+// Copyright 2025 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.
+
+import * as Host from '../../core/host/host.js';
+import * as ProjectSettings from '../project_settings/project_settings.js';
+
+import * as Persistence from './persistence.js';
+
+describe('AutomaticFileSystemManager', () => {
+  const AUTOMATIC_FILE_SYSTEM_CHANGED = Persistence.AutomaticFileSystemManager.Events.AUTOMATIC_FILE_SYSTEM_CHANGED;
+  const {AutomaticFileSystemManager} = Persistence.AutomaticFileSystemManager;
+  const root = '/path/to/bar';
+  const uuid = '549bbf9b-48b2-4af7-aebd-d3ba68993094';
+  const hostConfig = {devToolsAutomaticFileSystems: {enabled: true}};
+
+  afterEach(() => {
+    AutomaticFileSystemManager.removeInstance();
+  });
+
+  it('initially doesn\'t report an automatic file system', () => {
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+    sinon.stub(projectSettingsModel, 'projectSettings').value({});
+
+    const manager = AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+
+    assert.isNull(manager.automaticFileSystem);
+  });
+
+  it('doesn\'t listen to project settings changes when `devToolsAutomaticFileSystems` is off', () => {
+    const hostConfig = {devToolsAutomaticFileSystems: {enabled: false}};
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+
+    AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+
+    assert(projectSettingsModel.addEventListener.notCalled);
+  });
+
+  it('attempts to automatically connect the file system initially', () => {
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+    sinon.stub(projectSettingsModel, 'projectSettings').value({workspace: {root, uuid}});
+
+    const manager = AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+
+    assert.deepEqual(manager.automaticFileSystem, {root, uuid, state: 'connecting'});
+    assert(inspectorFrontendHost.connectAutomaticFileSystem.calledOnceWith(root, uuid, false));
+  });
+
+  it('reflects state correctly when automatic connection succeeds', async () => {
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+    sinon.stub(projectSettingsModel, 'projectSettings').value({workspace: {root, uuid}});
+
+    const manager = AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+    const [, , , setupCallback] = inspectorFrontendHost.connectAutomaticFileSystem.lastCall.args;
+    setupCallback({success: true});
+    const automaticFileSystem = await manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+
+    assert.strictEqual(automaticFileSystem, manager.automaticFileSystem);
+    assert.deepEqual(automaticFileSystem, {root, uuid, state: 'connected'});
+  });
+
+  it('reflects state correctly when automatic connection fails', async () => {
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+    sinon.stub(projectSettingsModel, 'projectSettings').value({workspace: {root, uuid}});
+
+    const manager = AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+    const [, , , setupCallback] = inspectorFrontendHost.connectAutomaticFileSystem.lastCall.args;
+    setupCallback({success: false});
+    const automaticFileSystem = await manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+
+    assert.strictEqual(automaticFileSystem, manager.automaticFileSystem);
+    assert.deepEqual(automaticFileSystem, {root, uuid, state: 'disconnected'});
+  });
+
+  it('performs first-time setup of automatic file system correctly', async () => {
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+    sinon.stub(projectSettingsModel, 'projectSettings').value({workspace: {root, uuid}});
+    const manager = AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+    const [, , , setupCallback] = inspectorFrontendHost.connectAutomaticFileSystem.lastCall.args;
+    setupCallback({success: false});
+    await manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+    inspectorFrontendHost.connectAutomaticFileSystem.reset();
+    const connectingPromise = manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+
+    const successPromise = manager.connectAutomaticFileSystem(/* addIfMissing= */ true);
+    assert.strictEqual(manager.automaticFileSystem, await connectingPromise);
+    assert.deepEqual(manager.automaticFileSystem, {root, uuid, state: 'connecting'});
+    const connectedPromise = manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+    const [, , , connectCallback] = inspectorFrontendHost.connectAutomaticFileSystem.lastCall.args;
+    connectCallback({success: true});
+
+    const [success, automaticFileSystem] = await Promise.all([successPromise, connectedPromise]);
+    assert.isTrue(success);
+    assert.strictEqual(manager.automaticFileSystem, automaticFileSystem);
+    assert.deepEqual(manager.automaticFileSystem, {root, uuid, state: 'connected'});
+  });
+
+  it('correctly disconnects automatic file systems', async () => {
+    const inspectorFrontendHost = sinon.createStubInstance(Host.InspectorFrontendHost.InspectorFrontendHostStub);
+    const projectSettingsModel = sinon.createStubInstance(ProjectSettings.ProjectSettingsModel.ProjectSettingsModel);
+    sinon.stub(projectSettingsModel, 'projectSettings').value({workspace: {root, uuid}});
+    const manager = AutomaticFileSystemManager.instance({
+      forceNew: true,
+      hostConfig,
+      inspectorFrontendHost,
+      projectSettingsModel,
+    });
+    const [, , , setupCallback] = inspectorFrontendHost.connectAutomaticFileSystem.lastCall.args;
+    setupCallback({success: true});
+    await manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+    const automaticFileSystemPromise = manager.once(AUTOMATIC_FILE_SYSTEM_CHANGED);
+
+    manager.disconnectedAutomaticFileSystem();
+
+    const automaticFileSystem = await automaticFileSystemPromise;
+    assert(inspectorFrontendHost.disconnectAutomaticFileSystem.calledOnceWith(root));
+    assert.strictEqual(manager.automaticFileSystem, automaticFileSystem);
+    assert.deepEqual(manager.automaticFileSystem, {root, uuid, state: 'disconnected'});
+  });
+});