Change SmbMountResult values to use kConstantSyntax naming

Bug: None
Change-Id: Icde3c290e2cb136b15542ce2fc9d1884b08d335d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2035811Reviewed-by: Austin Tankiang <austinct@chromium.org>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738042}

chrome/browser/chromeos/smb_client/smb_errors.cc

@@ -106,43 +106,43 @@ SmbMountResult TranslateErrorToMountResult(smbprovider::ErrorType error) {
 
   switch (error) {
     case smbprovider::ERROR_OK:
-      return SmbMountResult::SUCCESS;
+      return SmbMountResult::kSuccess;
     case smbprovider::ERROR_EXISTS:
     case smbprovider::ERROR_IN_USE:
-      return SmbMountResult::MOUNT_EXISTS;
+      return SmbMountResult::kMountExists;
     case smbprovider::ERROR_NOT_FOUND:
     case smbprovider::ERROR_NOT_A_DIRECTORY:
-      return SmbMountResult::NOT_FOUND;
+      return SmbMountResult::kNotFound;
     case smbprovider::ERROR_ACCESS_DENIED:
     case smbprovider::ERROR_SECURITY:
-      return SmbMountResult::AUTHENTICATION_FAILED;
+      return SmbMountResult::kAuthenticationFailed;
     case smbprovider::ERROR_SMB1_UNSUPPORTED:
-      return SmbMountResult::UNSUPPORTED_DEVICE;
+      return SmbMountResult::kUnsupportedDevice;
     case smbprovider::ERROR_INVALID_URL:
-      return SmbMountResult::INVALID_URL;
+      return SmbMountResult::kInvalidUrl;
     case smbprovider::ERROR_IO:
-      return SmbMountResult::IO_ERROR;
+      return SmbMountResult::kIoError;
     case smbprovider::ERROR_TOO_MANY_OPENED:
-      return SmbMountResult::TOO_MANY_OPENED;
+      return SmbMountResult::kTooManyOpened;
     case smbprovider::ERROR_NO_MEMORY:
     case smbprovider::ERROR_NO_SPACE:
-      return SmbMountResult::OUT_OF_MEMORY;
+      return SmbMountResult::kOutOfMemory;
     case smbprovider::ERROR_INVALID_OPERATION:
-      return SmbMountResult::INVALID_OPERATION;
+      return SmbMountResult::kInvalidOperation;
     case smbprovider::ERROR_ABORT:
-      return SmbMountResult::ABORTED;
+      return SmbMountResult::kAborted;
     case smbprovider::ERROR_DBUS_PARSE_FAILED:
-      return SmbMountResult::DBUS_PARSE_FAILED;
+      return SmbMountResult::kDbusParseFailed;
     case smbprovider::ERROR_NOT_A_FILE:
     case smbprovider::ERROR_NOT_EMPTY:
     case smbprovider::ERROR_FAILED:
-      return SmbMountResult::UNKNOWN_FAILURE;
+      return SmbMountResult::kUnknownFailure;
     default:
       break;
   }
 
   NOTREACHED();
-  return SmbMountResult::UNKNOWN_FAILURE;
+  return SmbMountResult::kUnknownFailure;
 }
 
 SmbMountResult TranslateErrorToMountResult(base::File::Error error) {

chrome/browser/chromeos/smb_client/smb_errors.h

@@ -17,22 +17,21 @@ namespace smb_client {
 // ui/webui/resources/cr_components/chromeos/smb_shares/smb_browser_proxy.js
 // and the NativeSmbFileShare_MountResult enum in enums.xml.
 enum class SmbMountResult {
-  // TODO(allenvic): Change syntax to kConstantSyntax.
-  SUCCESS = 0,                 // Mount succeeded.
-  UNKNOWN_FAILURE = 1,         // Mount failed in an unrecognized way.
-  AUTHENTICATION_FAILED = 2,   // Authentication to the share failed.
-  NOT_FOUND = 3,               // The specified share was not found.
-  UNSUPPORTED_DEVICE = 4,      // The specified share is not supported.
-  MOUNT_EXISTS = 5,            // The specified share is already mounted.
-  INVALID_URL = 6,             // The mount URL is an invalid SMB URL.
-  INVALID_OPERATION = 7,       // libsmbclient returned invalid operation.
-  DBUS_PARSE_FAILED = 8,       // Parsing the D-Bus message or response failed.
-  OUT_OF_MEMORY = 9,           // The share is out of memory or storage.
-  ABORTED = 10,                // The operation was aborted.
-  IO_ERROR = 11,               // An I/O error occured.
-  TOO_MANY_OPENED = 12,        // There are too many shares open.
-  INVALID_SSO_URL = 13,        // The share URL is not valid when using SSO.
-  kMaxValue = INVALID_SSO_URL  // Max enum value for use in metrics.
+  kSuccess = 0,               // Mount succeeded.
+  kUnknownFailure = 1,        // Mount failed in an unrecognized way.
+  kAuthenticationFailed = 2,  // Authentication to the share failed.
+  kNotFound = 3,              // The specified share was not found.
+  kUnsupportedDevice = 4,     // The specified share is not supported.
+  kMountExists = 5,           // The specified share is already mounted.
+  kInvalidUrl = 6,            // The mount URL is an invalid SMB URL.
+  kInvalidOperation = 7,      // libsmbclient returned invalid operation.
+  kDbusParseFailed = 8,       // Parsing the D-Bus message or response failed.
+  kOutOfMemory = 9,           // The share is out of memory or storage.
+  kAborted = 10,              // The operation was aborted.
+  kIoError = 11,              // An I/O error occurred.
+  kTooManyOpened = 12,        // There are too many shares open.
+  kInvalidSsoUrl = 13,        // The share URL is not valid when using SSO.
+  kMaxValue = kInvalidSsoUrl  // Max enum value for use in metrics.
 };
 
 // Translates an smbprovider::ErrorType to a base::File::Error. Since

chrome/browser/chromeos/smb_client/smb_errors_unittest.cc

@@ -97,81 +97,81 @@ TEST_F(SmbErrorsTest, FileErrorToSmbError) {
 }
 
 TEST_F(SmbErrorsTest, SmbErrorToMountResult) {
-  EXPECT_EQ(SmbMountResult::SUCCESS,
+  EXPECT_EQ(SmbMountResult::kSuccess,
             TranslateErrorToMountResult(smbprovider::ERROR_OK));
-  EXPECT_EQ(SmbMountResult::UNKNOWN_FAILURE,
+  EXPECT_EQ(SmbMountResult::kUnknownFailure,
             TranslateErrorToMountResult(smbprovider::ERROR_FAILED));
-  EXPECT_EQ(SmbMountResult::MOUNT_EXISTS,
+  EXPECT_EQ(SmbMountResult::kMountExists,
             TranslateErrorToMountResult(smbprovider::ERROR_IN_USE));
-  EXPECT_EQ(SmbMountResult::MOUNT_EXISTS,
+  EXPECT_EQ(SmbMountResult::kMountExists,
             TranslateErrorToMountResult(smbprovider::ERROR_EXISTS));
-  EXPECT_EQ(SmbMountResult::NOT_FOUND,
+  EXPECT_EQ(SmbMountResult::kNotFound,
             TranslateErrorToMountResult(smbprovider::ERROR_NOT_FOUND));
-  EXPECT_EQ(SmbMountResult::AUTHENTICATION_FAILED,
+  EXPECT_EQ(SmbMountResult::kAuthenticationFailed,
             TranslateErrorToMountResult(smbprovider::ERROR_ACCESS_DENIED));
-  EXPECT_EQ(SmbMountResult::TOO_MANY_OPENED,
+  EXPECT_EQ(SmbMountResult::kTooManyOpened,
             TranslateErrorToMountResult(smbprovider::ERROR_TOO_MANY_OPENED));
-  EXPECT_EQ(SmbMountResult::OUT_OF_MEMORY,
+  EXPECT_EQ(SmbMountResult::kOutOfMemory,
             TranslateErrorToMountResult(smbprovider::ERROR_NO_MEMORY));
-  EXPECT_EQ(SmbMountResult::OUT_OF_MEMORY,
+  EXPECT_EQ(SmbMountResult::kOutOfMemory,
             TranslateErrorToMountResult(smbprovider::ERROR_NO_SPACE));
-  EXPECT_EQ(SmbMountResult::NOT_FOUND,
+  EXPECT_EQ(SmbMountResult::kNotFound,
             TranslateErrorToMountResult(smbprovider::ERROR_NOT_A_DIRECTORY));
-  EXPECT_EQ(SmbMountResult::INVALID_OPERATION,
+  EXPECT_EQ(SmbMountResult::kInvalidOperation,
             TranslateErrorToMountResult(smbprovider::ERROR_INVALID_OPERATION));
-  EXPECT_EQ(SmbMountResult::AUTHENTICATION_FAILED,
+  EXPECT_EQ(SmbMountResult::kAuthenticationFailed,
             TranslateErrorToMountResult(smbprovider::ERROR_SECURITY));
-  EXPECT_EQ(SmbMountResult::ABORTED,
+  EXPECT_EQ(SmbMountResult::kAborted,
             TranslateErrorToMountResult(smbprovider::ERROR_ABORT));
-  EXPECT_EQ(SmbMountResult::UNKNOWN_FAILURE,
+  EXPECT_EQ(SmbMountResult::kUnknownFailure,
             TranslateErrorToMountResult(smbprovider::ERROR_NOT_A_FILE));
-  EXPECT_EQ(SmbMountResult::UNKNOWN_FAILURE,
+  EXPECT_EQ(SmbMountResult::kUnknownFailure,
             TranslateErrorToMountResult(smbprovider::ERROR_NOT_EMPTY));
-  EXPECT_EQ(SmbMountResult::INVALID_URL,
+  EXPECT_EQ(SmbMountResult::kInvalidUrl,
             TranslateErrorToMountResult(smbprovider::ERROR_INVALID_URL));
-  EXPECT_EQ(SmbMountResult::IO_ERROR,
+  EXPECT_EQ(SmbMountResult::kIoError,
             TranslateErrorToMountResult(smbprovider::ERROR_IO));
-  EXPECT_EQ(SmbMountResult::DBUS_PARSE_FAILED,
+  EXPECT_EQ(SmbMountResult::kDbusParseFailed,
             TranslateErrorToMountResult(smbprovider::ERROR_DBUS_PARSE_FAILED));
 }
 
 TEST_F(SmbErrorsTest, FileErrorToMountResult) {
-  EXPECT_EQ(SmbMountResult::SUCCESS,
+  EXPECT_EQ(SmbMountResult::kSuccess,
             TranslateErrorToMountResult(base::File::FILE_OK));
-  EXPECT_EQ(SmbMountResult::UNKNOWN_FAILURE,
+  EXPECT_EQ(SmbMountResult::kUnknownFailure,
             TranslateErrorToMountResult(base::File::FILE_ERROR_FAILED));
-  EXPECT_EQ(SmbMountResult::MOUNT_EXISTS,
+  EXPECT_EQ(SmbMountResult::kMountExists,
             TranslateErrorToMountResult(base::File::FILE_ERROR_IN_USE));
-  EXPECT_EQ(SmbMountResult::MOUNT_EXISTS,
+  EXPECT_EQ(SmbMountResult::kMountExists,
             TranslateErrorToMountResult(base::File::FILE_ERROR_EXISTS));
-  EXPECT_EQ(SmbMountResult::NOT_FOUND,
+  EXPECT_EQ(SmbMountResult::kNotFound,
             TranslateErrorToMountResult(base::File::FILE_ERROR_NOT_FOUND));
-  EXPECT_EQ(SmbMountResult::AUTHENTICATION_FAILED,
+  EXPECT_EQ(SmbMountResult::kAuthenticationFailed,
             TranslateErrorToMountResult(base::File::FILE_ERROR_ACCESS_DENIED));
   EXPECT_EQ(
-      SmbMountResult::TOO_MANY_OPENED,
+      SmbMountResult::kTooManyOpened,
       TranslateErrorToMountResult(base::File::FILE_ERROR_TOO_MANY_OPENED));
-  EXPECT_EQ(SmbMountResult::OUT_OF_MEMORY,
+  EXPECT_EQ(SmbMountResult::kOutOfMemory,
             TranslateErrorToMountResult(base::File::FILE_ERROR_NO_MEMORY));
-  EXPECT_EQ(SmbMountResult::OUT_OF_MEMORY,
+  EXPECT_EQ(SmbMountResult::kOutOfMemory,
             TranslateErrorToMountResult(base::File::FILE_ERROR_NO_SPACE));
   EXPECT_EQ(
-      SmbMountResult::NOT_FOUND,
+      SmbMountResult::kNotFound,
       TranslateErrorToMountResult(base::File::FILE_ERROR_NOT_A_DIRECTORY));
   EXPECT_EQ(
-      SmbMountResult::INVALID_OPERATION,
+      SmbMountResult::kInvalidOperation,
       TranslateErrorToMountResult(base::File::FILE_ERROR_INVALID_OPERATION));
-  EXPECT_EQ(SmbMountResult::AUTHENTICATION_FAILED,
+  EXPECT_EQ(SmbMountResult::kAuthenticationFailed,
             TranslateErrorToMountResult(base::File::FILE_ERROR_SECURITY));
-  EXPECT_EQ(SmbMountResult::ABORTED,
+  EXPECT_EQ(SmbMountResult::kAborted,
             TranslateErrorToMountResult(base::File::FILE_ERROR_ABORT));
-  EXPECT_EQ(SmbMountResult::UNKNOWN_FAILURE,
+  EXPECT_EQ(SmbMountResult::kUnknownFailure,
             TranslateErrorToMountResult(base::File::FILE_ERROR_NOT_A_FILE));
-  EXPECT_EQ(SmbMountResult::UNKNOWN_FAILURE,
+  EXPECT_EQ(SmbMountResult::kUnknownFailure,
             TranslateErrorToMountResult(base::File::FILE_ERROR_NOT_EMPTY));
-  EXPECT_EQ(SmbMountResult::INVALID_URL,
+  EXPECT_EQ(SmbMountResult::kInvalidUrl,
             TranslateErrorToMountResult(base::File::FILE_ERROR_INVALID_URL));
-  EXPECT_EQ(SmbMountResult::IO_ERROR,
+  EXPECT_EQ(SmbMountResult::kIoError,
             TranslateErrorToMountResult(base::File::FILE_ERROR_IO));
 }
 

chrome/browser/chromeos/smb_client/smb_service.cc

@@ -271,14 +271,14 @@ void SmbService::Mount(const file_system_provider::MountOptions& options,
   // to obtain the ticket. If the user enters an IP address, Samba will give us
   // a permission error, which isn't correct or useful to the end user.
   if (use_kerberos && url::HostIsIPAddress(parsed_url.GetHost())) {
-    std::move(callback).Run(SmbMountResult::INVALID_SSO_URL);
+    std::move(callback).Run(SmbMountResult::kInvalidSsoUrl);
     return;
   }
 
   if (IsShareMounted(parsed_url)) {
     // Prevent a share from being mounted twice. Although technically possible,
     // the UX when doing so is incomplete.
-    std::move(callback).Run(SmbMountResult::MOUNT_EXISTS);
+    std::move(callback).Run(SmbMountResult::kMountExists);
     return;
   }
 
@@ -342,7 +342,7 @@ void SmbService::Mount(const file_system_provider::MountOptions& options,
                 smb_credentials_updater_->active_account_name());
       } else {
         LOG(WARNING) << "No Kerberos credential source available";
-        std::move(callback).Run(SmbMountResult::AUTHENTICATION_FAILED);
+        std::move(callback).Run(SmbMountResult::kAuthenticationFailed);
         return;
       }
     }
@@ -381,7 +381,7 @@ void SmbService::OnSmbfsMountDone(const std::string& smbfs_mount_id,
                                   SmbMountResult result) {
   RecordMountResult(result);
 
-  if (result != SmbMountResult::SUCCESS) {
+  if (result != SmbMountResult::kSuccess) {
     smbfs_shares_.erase(smbfs_mount_id);
     std::move(callback).Run(result);
     return;
@@ -390,7 +390,7 @@ void SmbService::OnSmbfsMountDone(const std::string& smbfs_mount_id,
   SmbFsShare* mount = smbfs_shares_[smbfs_mount_id].get();
   if (!mount) {
     LOG(ERROR) << "smbfs mount " << smbfs_mount_id << " does not exist";
-    std::move(callback).Run(SmbMountResult::UNKNOWN_FAILURE);
+    std::move(callback).Run(SmbMountResult::kUnknownFailure);
     return;
   }
 
@@ -399,7 +399,7 @@ void SmbService::OnSmbfsMountDone(const std::string& smbfs_mount_id,
   }
 
   RecordMountCount();
-  std::move(callback).Run(SmbMountResult::SUCCESS);
+  std::move(callback).Run(SmbMountResult::kSuccess);
 }
 
 void SmbService::OnMountResponse(

chrome/browser/chromeos/smb_client/smb_service_unittest.cc

@@ -151,25 +151,25 @@ class SmbServiceTest : public testing::Test {
   }
 
   void ExpectInvalidUrl(const std::string& url) {
-    SmbMountResult result = SmbMountResult::SUCCESS;
+    SmbMountResult result = SmbMountResult::kSuccess;
     smb_service_->Mount({} /* options */, base::FilePath(url),
                         "" /* username */, "" /* password */,
                         false /* use_chromad_kerberos */,
                         false /* should_open_file_manager_after_mount */,
                         false /* save_credentials */,
                         base::BindOnce(&SaveMountResult, &result));
-    EXPECT_EQ(result, SmbMountResult::INVALID_URL);
+    EXPECT_EQ(result, SmbMountResult::kInvalidUrl);
   }
 
   void ExpectInvalidSsoUrl(const std::string& url) {
-    SmbMountResult result = SmbMountResult::SUCCESS;
+    SmbMountResult result = SmbMountResult::kSuccess;
     smb_service_->Mount({} /* options */, base::FilePath(url),
                         "" /* username */, "" /* password */,
                         true /* use_chromad_kerberos */,
                         false /* should_open_file_manager_after_mount */,
                         false /* save_credentials */,
                         base::BindOnce(&SaveMountResult, &result));
-    EXPECT_EQ(result, SmbMountResult::INVALID_SSO_URL);
+    EXPECT_EQ(result, SmbMountResult::kInvalidSsoUrl);
   }
 
   void WaitForSetupComplete() {
@@ -265,7 +265,7 @@ TEST_F(SmbServiceTest, Mount) {
       false /* should_open_file_manager_after_mount */,
       false /* save_credentials */,
       base::BindLambdaForTesting([&run_loop](SmbMountResult result) {
-        EXPECT_EQ(SmbMountResult::SUCCESS, result);
+        EXPECT_EQ(SmbMountResult::kSuccess, result);
         run_loop.Quit();
       }));
   run_loop.Run();
@@ -312,7 +312,7 @@ TEST_F(SmbServiceTest, MountSaveCredentials) {
       false /* should_open_file_manager_after_mount */,
       true /* save_credentials */,
       base::BindLambdaForTesting([&run_loop](SmbMountResult result) {
-        EXPECT_EQ(SmbMountResult::SUCCESS, result);
+        EXPECT_EQ(SmbMountResult::kSuccess, result);
         run_loop.Quit();
       }));
   run_loop.Run();

chrome/browser/chromeos/smb_client/smbfs_share.cc

@@ -23,22 +23,22 @@ constexpr char kMountDirPrefix[] = "smbfs-";
 SmbMountResult MountErrorToMountResult(smbfs::mojom::MountError mount_error) {
   switch (mount_error) {
     case smbfs::mojom::MountError::kOk:
-      return SmbMountResult::SUCCESS;
+      return SmbMountResult::kSuccess;
     case smbfs::mojom::MountError::kTimeout:
-      return SmbMountResult::ABORTED;
+      return SmbMountResult::kAborted;
     case smbfs::mojom::MountError::kInvalidUrl:
-      return SmbMountResult::INVALID_URL;
+      return SmbMountResult::kInvalidUrl;
     case smbfs::mojom::MountError::kInvalidOptions:
-      return SmbMountResult::INVALID_OPERATION;
+      return SmbMountResult::kInvalidOperation;
     case smbfs::mojom::MountError::kNotFound:
-      return SmbMountResult::NOT_FOUND;
+      return SmbMountResult::kNotFound;
     case smbfs::mojom::MountError::kAccessDenied:
-      return SmbMountResult::AUTHENTICATION_FAILED;
+      return SmbMountResult::kAuthenticationFailed;
     case smbfs::mojom::MountError::kInvalidProtocol:
-      return SmbMountResult::UNSUPPORTED_DEVICE;
+      return SmbMountResult::kUnsupportedDevice;
     case smbfs::mojom::MountError::kUnknown:
     default:
-      return SmbMountResult::UNKNOWN_FAILURE;
+      return SmbMountResult::kUnknownFailure;
   }
 }
 
@@ -123,7 +123,7 @@ void SmbFsShare::OnMountDone(MountCallback callback,
 
   file_manager::VolumeManager::Get(profile_)->AddSmbFsVolume(
       host_->mount_path(), display_name_);
-  std::move(callback).Run(SmbMountResult::SUCCESS);
+  std::move(callback).Run(SmbMountResult::kSuccess);
 }
 
 void SmbFsShare::OnDisconnected() {

chrome/browser/chromeos/smb_client/smbfs_share_unittest.cc

@@ -157,7 +157,7 @@ TEST_F(SmbFsShareTest, Mount) {
 
   base::RunLoop run_loop;
   share.Mount(base::BindLambdaForTesting([&run_loop](SmbMountResult result) {
-    EXPECT_EQ(result, SmbMountResult::SUCCESS);
+    EXPECT_EQ(result, SmbMountResult::kSuccess);
     run_loop.Quit();
   }));
   run_loop.Run();
@@ -188,7 +188,7 @@ TEST_F(SmbFsShareTest, MountFailure) {
 
   base::RunLoop run_loop;
   share.Mount(base::BindLambdaForTesting([&run_loop](SmbMountResult result) {
-    EXPECT_EQ(result, SmbMountResult::ABORTED);
+    EXPECT_EQ(result, SmbMountResult::kAborted);
     run_loop.Quit();
   }));
   run_loop.Run();
@@ -235,7 +235,7 @@ TEST_F(SmbFsShareTest, UnmountOnDisconnect) {
 
   share.Mount(
       base::BindLambdaForTesting([&smbfs_receiver](SmbMountResult result) {
-        EXPECT_EQ(result, SmbMountResult::SUCCESS);
+        EXPECT_EQ(result, SmbMountResult::kSuccess);
 
         // Disconnect the Mojo service which should trigger the unmount.
         smbfs_receiver.reset();