Pass the lost and found directory name to DriveFS in the config struct.

Also, prepare to pass the myfiles directory as a mount option, but don't
actually send it yet - cros-disks isn't ready for it (and won't be until
after DriveFS runs as chronos) so would log the unsupported mount
option.

Bug: 928157
Change-Id: I2d38df787fb12b0a50a063aa445dc6c7d2e23597
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1623617Reviewed-by: Noel Gordon <noel@chromium.org>
Commit-Queue: Sam McNally <sammc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#662091}

chrome/browser/chromeos/drive/drive_integration_service.cc

@@ -591,6 +591,15 @@ class DriveIntegrationService::DriveFsHolder
     return Delegate::CreateMojoListener();
   }
 
+  base::FilePath GetMyFilesPath() override {
+    return file_manager::util::GetMyFilesFolderForProfile(profile_);
+  }
+
+  std::string GetLostAndFoundDirectoryName() override {
+    return l10n_util::GetStringUTF8(
+        IDS_FILE_BROWSER_RECOVERED_FILES_FROM_GOOGLE_DRIVE_DIRECTORY_NAME);
+  }
+
   Profile* const profile_;
   drivefs::DriveFsHost::MountObserver* const mount_observer_;
 

chromeos/components/drivefs/drivefs_host.cc

@@ -47,6 +47,7 @@ class DriveFsHost::MountState : public DriveFsSession,
                        CreateMojoConnection(host->account_token_delegate_.get(),
                                             host->delegate_),
                        host->GetDataPath(),
+                       host->delegate_->GetMyFilesPath(),
                        host->GetDefaultMountDirName(),
                        host->mount_observer_),
         host_(host) {
@@ -72,7 +73,8 @@ class DriveFsHost::MountState : public DriveFsSession,
     auto access_token = auth_delegate->GetCachedAccessToken();
     mojom::DriveFsConfigurationPtr config = {
         base::in_place, auth_delegate->GetAccountId().GetUserEmail(),
-        std::move(access_token), auth_delegate->IsMetricsCollectionEnabled()};
+        std::move(access_token), auth_delegate->IsMetricsCollectionEnabled(),
+        delegate->GetLostAndFoundDirectoryName()};
     return DriveFsConnection::Create(delegate->CreateMojoListener(),
                                      std::move(config));
   }

chromeos/components/drivefs/drivefs_host.h

@@ -54,6 +54,8 @@ class COMPONENT_EXPORT(DRIVEFS) DriveFsHost {
 
     virtual drive::DriveNotificationManager& GetDriveNotificationManager() = 0;
     virtual std::unique_ptr<DriveFsBootstrapListener> CreateMojoListener();
+    virtual base::FilePath GetMyFilesPath() = 0;
+    virtual std::string GetLostAndFoundDirectoryName() = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);

chromeos/components/drivefs/drivefs_host_unittest.cc

@@ -141,6 +141,14 @@ class TestingDriveFsHostDelegate : public DriveFsHost::Delegate,
         std::move(pending_bootstrap_));
   }
 
+  std::string GetLostAndFoundDirectoryName() override {
+    return "recovered files";
+  }
+
+  base::FilePath GetMyFilesPath() override {
+    return base::FilePath("/MyFiles");
+  }
+
   const std::unique_ptr<service_manager::Connector> connector_;
   const AccountId account_id_;
   mojom::DriveFsBootstrapPtrInfo pending_bootstrap_;
@@ -401,6 +409,8 @@ class DriveFsHostTest : public ::testing::Test, public mojom::DriveFsBootstrap {
             mojom::DriveFsRequest drive_fs_request,
             mojom::DriveFsDelegatePtr delegate) override {
     EXPECT_EQ("test@example.com", config->user_email);
+    EXPECT_EQ("recovered files",
+              config->lost_and_found_directory_name.value_or("<None>"));
     init_access_token_ = std::move(config->access_token);
     binding_.Bind(std::move(drive_fs_request));
     mojo::FuseInterface(std::move(pending_delegate_request_),

chromeos/components/drivefs/drivefs_session.cc

@@ -34,6 +34,7 @@ class DiskMounterImpl : public DiskMounter,
 
   void Mount(const base::UnguessableToken& token,
              const base::FilePath& data_path,
+             const base::FilePath& my_files_path,
              const std::string& desired_mount_dir_name,
              base::OnceCallback<void(base::FilePath)> callback) override {
     DCHECK(mount_path_.empty());
@@ -100,6 +101,7 @@ DriveFsSession::DriveFsSession(base::OneShotTimer* timer,
                                std::unique_ptr<DiskMounter> disk_mounter,
                                std::unique_ptr<DriveFsConnection> connection,
                                const base::FilePath& data_path,
+                               const base::FilePath& my_files_path,
                                const std::string& desired_mount_dir_name,
                                MountObserver* observer)
     : timer_(timer),
@@ -111,7 +113,7 @@ DriveFsSession::DriveFsSession(base::OneShotTimer* timer,
                            base::Unretained(this)));
   CHECK(token);
   drivefs_ = &connection_->GetDriveFs();
-  disk_mounter_->Mount(token, data_path, desired_mount_dir_name,
+  disk_mounter_->Mount(token, data_path, my_files_path, desired_mount_dir_name,
                        base::BindOnce(&DriveFsSession::OnDiskMountCompleted,
                                       base::Unretained(this)));
   timer_->Start(

chromeos/components/drivefs/drivefs_session.h

@@ -26,6 +26,7 @@ class COMPONENT_EXPORT(DRIVEFS) DiskMounter {
   virtual ~DiskMounter() = default;
   virtual void Mount(const base::UnguessableToken& token,
                      const base::FilePath& data_path,
+                     const base::FilePath& my_files_path,
                      const std::string& desired_mount_dir_name,
                      base::OnceCallback<void(base::FilePath)> callback) = 0;
 
@@ -68,6 +69,7 @@ class COMPONENT_EXPORT(DRIVEFS) DriveFsSession : public mojom::DriveFsDelegate {
                  std::unique_ptr<DiskMounter> disk_mounter,
                  std::unique_ptr<DriveFsConnection> connection,
                  const base::FilePath& data_path,
+                 const base::FilePath& my_files_path,
                  const std::string& desired_mount_dir_name,
                  MountObserver* observer);
   ~DriveFsSession() override;

chromeos/components/drivefs/drivefs_session_unittest.cc

@@ -24,6 +24,7 @@ namespace {
 constexpr char kExpectedMountDir[] = "drivefs-salt-g-ID";
 constexpr char kExpectedMountPath[] = "/media/drivefsroot/mountdir";
 constexpr char kExpectedDataDir[] = "/path/to/profile/GCache/v2/salt-g-ID";
+constexpr char kExpectedMyFilesDir[] = "/path/to/profile/MyFiles";
 
 static const base::Optional<base::TimeDelta> kEmptyDelay;
 static const base::Optional<base::TimeDelta> kDefaultDelay =
@@ -43,11 +44,15 @@ class DriveFsDiskMounterTest : public testing::Test {
         disk_manager_,
         MountPath(
             testing::StartsWith("drivefs://"), "", kExpectedMountDir,
-            testing::Contains("datadir=/path/to/profile/GCache/v2/salt-g-ID"),
+            testing::AllOf(testing::Contains(
+                               "datadir=/path/to/profile/GCache/v2/salt-g-ID"),
+                           testing::Not(testing::Contains(
+                               "myfiles=/path/to/profile/MyFiles"))),
             _, chromeos::MOUNT_ACCESS_MODE_READ_WRITE))
         .WillOnce(testing::SaveArg<0>(&source));
 
-    mounter->Mount(token, base::FilePath(kExpectedDataDir), kExpectedMountDir,
+    mounter->Mount(token, base::FilePath(kExpectedDataDir),
+                   base::FilePath(kExpectedMyFilesDir), kExpectedMountDir,
                    base::BindOnce(&DriveFsDiskMounterTest::OnCompleted,
                                   base::Unretained(this)));
     testing::Mock::VerifyAndClear(&disk_manager_);
@@ -168,6 +173,7 @@ class MockDiskMounter : public DiskMounter {
 
   void Mount(const base::UnguessableToken& token,
              const base::FilePath& data_path,
+             const base::FilePath& my_files_path,
              const std::string& desired_mount_dir_name,
              base::OnceCallback<void(base::FilePath)> callback) override {
     callback_ = std::move(callback);
@@ -237,12 +243,14 @@ class DriveFsSessionForTest : public DriveFsSession {
                         std::unique_ptr<DiskMounter> disk_mounter,
                         std::unique_ptr<DriveFsConnection> connection,
                         const base::FilePath& data_path,
+                        const base::FilePath& my_files_path,
                         const std::string& desired_mount_dir_name,
                         MountObserver* observer)
       : DriveFsSession(timer,
                        std::move(disk_mounter),
                        std::move(connection),
                        data_path,
+                       my_files_path,
                        desired_mount_dir_name,
                        observer) {}
   ~DriveFsSessionForTest() override = default;
@@ -291,7 +299,7 @@ class DriveFsSessionTest : public ::testing::Test,
                 OnMountCalled(_, data_path, kExpectedMountDir));
     session_ = std::make_unique<DriveFsSessionForTest>(
         &timer_, std::move(mounter), std::move(connection), data_path,
-        kExpectedMountDir, this);
+        base::FilePath(kExpectedMyFilesDir), kExpectedMountDir, this);
     holder_->delegate = session_.get();
     ASSERT_FALSE(session_->is_mounted());
   }

chromeos/components/drivefs/mojom/drivefs.mojom

@@ -100,7 +100,7 @@ interface DriveFsDelegate {
   OnHeartbeat();
 };
 
-// Next MinVersion: 3
+// Next MinVersion: 4
 struct DriveFsConfiguration {
   string user_email;
 
@@ -109,6 +109,11 @@ struct DriveFsConfiguration {
 
   [MinVersion=2]
   bool enable_metrics = false;
+
+  // The directory name to use for lost and found within the user's My files
+  // directory.
+  [MinVersion=3]
+  string? lost_and_found_directory_name;
 };
 
 enum AccessTokenStatus {