Add pref to control verbose logging in DriveFS

Bug: 1049071
Change-Id: I4156e737f1cd760d783f086be2d058609a50b4fd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2208327Reviewed-by: Stuart Langley <slangley@chromium.org>
Reviewed-by: Xiyuan Xia <xiyuan@chromium.org>
Reviewed-by: Sergei Datsenko <dats@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Commit-Queue: Austin Tankiang <austinct@chromium.org>
Cr-Commit-Position: refs/heads/master@{#774989}

chrome/browser/chromeos/drive/drive_integration_service.cc

@@ -518,6 +518,11 @@ class DriveIntegrationService::DriveFsHolder
         IDS_FILE_BROWSER_RECOVERED_FILES_FROM_GOOGLE_DRIVE_DIRECTORY_NAME);
   }
 
+  bool IsVerboseLoggingEnabled() override {
+    return profile_->GetPrefs()->GetBoolean(
+        prefs::kDriveFsEnableVerboseLogging);
+  }
+
   Profile* const profile_;
   drivefs::DriveFsHost::MountObserver* const mount_observer_;
 

chrome/browser/chromeos/preferences.cc

@@ -266,6 +266,8 @@ void Preferences::RegisterProfilePrefs(
                                 false);
   registry->RegisterStringPref(drive::prefs::kDriveFsProfileSalt, "");
   registry->RegisterBooleanPref(drive::prefs::kDriveFsPinnedMigrated, false);
+  registry->RegisterBooleanPref(drive::prefs::kDriveFsEnableVerboseLogging,
+                                false);
   // We don't sync ::prefs::kLanguageCurrentInputMethod and PreviousInputMethod
   // because they're just used to track the logout state of the device.
   registry->RegisterStringPref(::prefs::kLanguageCurrentInputMethod, "");

chromeos/components/drivefs/drivefs_host.cc

@@ -78,7 +78,8 @@ class DriveFsHost::MountState : public DriveFsSession,
         std::move(access_token),
         auth_delegate->IsMetricsCollectionEnabled(),
         delegate->GetLostAndFoundDirectoryName(),
-        base::FeatureList::IsEnabled(chromeos::features::kDriveFsMirroring)};
+        base::FeatureList::IsEnabled(chromeos::features::kDriveFsMirroring),
+        delegate->IsVerboseLoggingEnabled()};
     return DriveFsConnection::Create(delegate->CreateMojoListener(),
                                      std::move(config));
   }

chromeos/components/drivefs/drivefs_host.h

@@ -57,6 +57,7 @@ class COMPONENT_EXPORT(DRIVEFS) DriveFsHost {
     virtual std::unique_ptr<DriveFsBootstrapListener> CreateMojoListener();
     virtual base::FilePath GetMyFilesPath() = 0;
     virtual std::string GetLostAndFoundDirectoryName() = 0;
+    virtual bool IsVerboseLoggingEnabled() = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);

chromeos/components/drivefs/drivefs_host_unittest.cc

@@ -114,6 +114,10 @@ class TestingDriveFsHostDelegate : public DriveFsHost::Delegate,
     pending_bootstrap_ = std::move(pending_bootstrap);
   }
 
+  void set_verbose_logging_enabled(bool enabled) {
+    verbose_logging_enabled_ = enabled;
+  }
+
   // DriveFsHost::MountObserver:
   MOCK_METHOD1(OnMounted, void(const base::FilePath&));
   MOCK_METHOD2(OnMountFailed,
@@ -153,9 +157,12 @@ class TestingDriveFsHostDelegate : public DriveFsHost::Delegate,
     return base::FilePath("/MyFiles");
   }
 
+  bool IsVerboseLoggingEnabled() override { return verbose_logging_enabled_; }
+
   signin::IdentityManager* const identity_manager_;
   const AccountId account_id_;
   mojo::PendingRemote<mojom::DriveFsBootstrap> pending_bootstrap_;
+  bool verbose_logging_enabled_ = false;
   invalidation::FakeInvalidationService invalidation_service_;
   drive::DriveNotificationManager drive_notification_manager_;
 
@@ -295,6 +302,7 @@ class DriveFsHostTest : public ::testing::Test, public mojom::DriveFsBootstrap {
     EXPECT_EQ("test@example.com", config->user_email);
     EXPECT_EQ("recovered files",
               config->lost_and_found_directory_name.value_or("<None>"));
+    verbose_logging_enabled_ = config->enable_verbose_logging;
     init_access_token_ = std::move(config->access_token);
     receiver_.Bind(std::move(drive_fs_receiver));
     mojo::FusePipes(std::move(pending_delegate_receiver_), std::move(delegate));
@@ -311,6 +319,7 @@ class DriveFsHostTest : public ::testing::Test, public mojom::DriveFsBootstrap {
   std::unique_ptr<TestingDriveFsHostDelegate> host_delegate_;
   std::unique_ptr<DriveFsHost> host_;
   base::MockOneShotTimer* timer_;
+  base::Optional<bool> verbose_logging_enabled_;
 
   mojo::Receiver<mojom::DriveFsBootstrap> bootstrap_receiver_{this};
   MockDriveFs mock_drivefs_;
@@ -336,6 +345,8 @@ TEST_F(DriveFsHostTest, Basic) {
 
   ASSERT_NO_FATAL_FAILURE(DoMount());
   EXPECT_FALSE(init_access_token_);
+  ASSERT_TRUE(verbose_logging_enabled_);
+  EXPECT_FALSE(verbose_logging_enabled_.value());
 
   EXPECT_EQ(base::FilePath("/media/drivefsroot/salt-g-ID"),
             host_->GetMountPath());
@@ -348,6 +359,15 @@ TEST_F(DriveFsHostTest, Basic) {
   run_loop.Run();
 }
 
+TEST_F(DriveFsHostTest, EnableVerboseLogging) {
+  ASSERT_FALSE(host_->IsMounted());
+
+  host_delegate_->set_verbose_logging_enabled(true);
+  ASSERT_NO_FATAL_FAILURE(DoMount());
+  ASSERT_TRUE(verbose_logging_enabled_);
+  EXPECT_TRUE(verbose_logging_enabled_.value());
+}
+
 TEST_F(DriveFsHostTest, GetMountPathWhileUnmounted) {
   EXPECT_EQ(base::FilePath("/media/fuse/drivefs-salt-g-ID"),
             host_->GetMountPath());

chromeos/components/drivefs/mojom/drivefs.mojom

@@ -111,7 +111,7 @@ interface DriveFsDelegate {
   OnHeartbeat();
 };
 
-// Next MinVersion: 5
+// Next MinVersion: 6
 struct DriveFsConfiguration {
   string user_email;
 
@@ -128,6 +128,9 @@ struct DriveFsConfiguration {
 
   [MinVersion=4]
   bool enable_experimental_mirroring = false;
+
+  [MinVersion=5]
+  bool enable_verbose_logging = false;
 };
 
 enum AccessTokenStatus {

components/drive/drive_pref_names.cc

@@ -15,6 +15,9 @@ const char kDisableDrive[] = "gdata.disabled";
 // The pref prefix should remain as "gdata" for backward compatibility.
 const char kDisableDriveOverCellular[] = "gdata.cellular.disabled";
 
+// A boolean pref to enable or disable verbose logging in DriveFS.
+const char kDriveFsEnableVerboseLogging[] = "drivefs.enable_verbose_logging";
+
 // A string pref containing a random salt used to obfuscate account IDs
 // when passed to drivefs.
 const char kDriveFsProfileSalt[] = "drivefs.profile_salt";

components/drive/drive_pref_names.h

@@ -12,6 +12,7 @@ namespace prefs {
 
 extern const char kDisableDrive[];
 extern const char kDisableDriveOverCellular[];
+extern const char kDriveFsEnableVerboseLogging[];
 extern const char kDriveFsProfileSalt[];
 extern const char kDriveFsPinnedMigrated[];
 extern const char kDriveFsWasLaunchedAtLeastOnce[];