Switch borealis enums to enum classes

This is preferred for type-safety reasons.

Bug: b/171760827
Change-Id: Ib589b5f16f99097b9d885a5d99a04741945c55ed
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2500645Reviewed-by: Daniel Ng <danielng@google.com>
Commit-Queue: Nic Hollingum <hollingum@google.com>
Cr-Commit-Position: refs/heads/master@{#821105}

chrome/browser/chromeos/borealis/borealis_app_launcher.cc

@@ -22,7 +22,7 @@ void BorealisAppLauncher::Launch(const BorealisContext& ctx,
   //
   // TODO(b/170677773): Launch a _certain_ application...
   if (app_id == kBorealisAppId) {
-    std::move(callback).Run(kSuccess);
+    std::move(callback).Run(LaunchResult::kSuccess);
     return;
   }
 
@@ -31,7 +31,7 @@ void BorealisAppLauncher::Launch(const BorealisContext& ctx,
           ->GetRegistration(app_id);
 
   if (!reg) {
-    std::move(callback).Run(kUnknownApp);
+    std::move(callback).Run(LaunchResult::kUnknownApp);
     return;
   }
 
@@ -54,16 +54,16 @@ void BorealisAppLauncher::Launch(const BorealisContext& ctx,
                 if (!response) {
                   LOG(ERROR)
                       << "Failed to launch app: No response from cicerone";
-                  std::move(callback).Run(kNoResponse);
+                  std::move(callback).Run(LaunchResult::kNoResponse);
                   return;
                 }
                 if (!response->success()) {
                   LOG(ERROR)
                       << "Failed to launch app: " << response->failure_reason();
-                  std::move(callback).Run(kError);
+                  std::move(callback).Run(LaunchResult::kError);
                   return;
                 }
-                std::move(callback).Run(kSuccess);
+                std::move(callback).Run(LaunchResult::kSuccess);
               },
               std::move(callback)));
 }

chrome/browser/chromeos/borealis/borealis_app_launcher.h

@@ -16,7 +16,7 @@ class BorealisContext;
 // Helper class responsible for launching borealis' apps.
 class BorealisAppLauncher {
  public:
-  enum LaunchResult {
+  enum class LaunchResult {
     kSuccess,
     kUnknownApp,
     kNoResponse,

chrome/browser/chromeos/borealis/borealis_app_launcher_unittest.cc

@@ -84,21 +84,24 @@ class BorealisAppLauncherTest : public testing::Test {
 
 TEST_F(BorealisAppLauncherTest, LauncherAppAlwaysWorks) {
   CallbackFactory callback_check;
-  EXPECT_CALL(callback_check, Call(BorealisAppLauncher::kSuccess));
+  EXPECT_CALL(callback_check,
+              Call(BorealisAppLauncher::LaunchResult::kSuccess));
   BorealisAppLauncher::Launch(Context(), kBorealisAppId,
                               callback_check.BindOnce());
 }
 
 TEST_F(BorealisAppLauncherTest, UnknownAppCausesError) {
   CallbackFactory callback_check;
-  EXPECT_CALL(callback_check, Call(BorealisAppLauncher::kUnknownApp));
+  EXPECT_CALL(callback_check,
+              Call(BorealisAppLauncher::LaunchResult::kUnknownApp));
   BorealisAppLauncher::Launch(Context(), "non_existent_app",
                               callback_check.BindOnce());
 }
 
 TEST_F(BorealisAppLauncherTest, NoResponseCausesError) {
   CallbackFactory callback_check;
-  EXPECT_CALL(callback_check, Call(BorealisAppLauncher::kNoResponse));
+  EXPECT_CALL(callback_check,
+              Call(BorealisAppLauncher::LaunchResult::kNoResponse));
   std::string baz_id = SetDummyApp("foo.desktop");
   Cicerone()->SetOnLaunchContainerApplicationCallback(
       base::BindLambdaForTesting(
@@ -115,7 +118,7 @@ TEST_F(BorealisAppLauncherTest, NoResponseCausesError) {
 
 TEST_F(BorealisAppLauncherTest, ErrorResponseIsPropagated) {
   CallbackFactory callback_check;
-  EXPECT_CALL(callback_check, Call(BorealisAppLauncher::kError));
+  EXPECT_CALL(callback_check, Call(BorealisAppLauncher::LaunchResult::kError));
   std::string baz_id = SetDummyApp("bar.desktop");
   Cicerone()->SetOnLaunchContainerApplicationCallback(
       base::BindLambdaForTesting(
@@ -134,7 +137,8 @@ TEST_F(BorealisAppLauncherTest, ErrorResponseIsPropagated) {
 
 TEST_F(BorealisAppLauncherTest, SuccessfulLaunchHasSuccessResponse) {
   CallbackFactory callback_check;
-  EXPECT_CALL(callback_check, Call(BorealisAppLauncher::kSuccess));
+  EXPECT_CALL(callback_check,
+              Call(BorealisAppLauncher::LaunchResult::kSuccess));
   std::string baz_id = SetDummyApp("baz.desktop");
   Cicerone()->SetOnLaunchContainerApplicationCallback(
       base::BindLambdaForTesting(

chrome/browser/chromeos/borealis/borealis_context_manager.h

@@ -17,12 +17,12 @@ class BorealisContext;
 class BorealisContextManager : public KeyedService {
  public:
   // A list of possible outcomes for an attempt to startup borealis.
-  enum Status {
-    kSuccess = 0,
-    kMountFailed = 1,
-    kDiskImageFailed = 2,
-    kStartVmFailed = 3,
-    kAwaitBorealisStartupFailed = 4,
+  enum class Status {
+    kSuccess,
+    kMountFailed,
+    kDiskImageFailed,
+    kStartVmFailed,
+    kAwaitBorealisStartupFailed,
   };
 
   // An attempt to launch borealis. If the launch succeeds, holds a reference to

chrome/browser/chromeos/borealis/borealis_context_manager_impl.cc

@@ -15,15 +15,15 @@ namespace {
 std::ostream& operator<<(std::ostream& stream,
                          borealis::BorealisContextManager::Status status) {
   switch (status) {
-    case borealis::BorealisContextManager::kSuccess:
+    case borealis::BorealisContextManager::Status::kSuccess:
       return stream << "Success";
-    case borealis::BorealisContextManager::kMountFailed:
+    case borealis::BorealisContextManager::Status::kMountFailed:
       return stream << "Mount Failed";
-    case borealis::BorealisContextManager::kDiskImageFailed:
+    case borealis::BorealisContextManager::Status::kDiskImageFailed:
       return stream << "Disk Image Failed";
-    case borealis::BorealisContextManager::kStartVmFailed:
+    case borealis::BorealisContextManager::Status::kStartVmFailed:
       return stream << "Start VM Failed";
-    case borealis::BorealisContextManager::kAwaitBorealisStartupFailed:
+    case borealis::BorealisContextManager::Status::kAwaitBorealisStartupFailed:
       return stream << "Await Borealis Startup Failed";
   }
 }
@@ -72,7 +72,7 @@ void BorealisContextManagerImpl::NextTask() {
   if (task_queue_.empty()) {
     context_.set_borealis_running(true);
     is_borealis_running_ = true;
-    startup_status_ = kSuccess;
+    startup_status_ = Status::kSuccess;
     OnQueueComplete();
     return;
   }
@@ -86,7 +86,7 @@ void BorealisContextManagerImpl::NextTask() {
 void BorealisContextManagerImpl::TaskCallback(Status status,
                                               std::string error) {
   startup_status_ = status;
-  if (startup_status_ == kSuccess) {
+  if (startup_status_ == Status::kSuccess) {
     NextTask();
     return;
   }
@@ -106,7 +106,7 @@ void BorealisContextManagerImpl::OnQueueComplete() {
 }
 
 BorealisContextManager::Result BorealisContextManagerImpl::GetResult() {
-  if (startup_status_ == kSuccess) {
+  if (startup_status_ == Status::kSuccess) {
     return BorealisContextManager::Result(&context_);
   }
   return BorealisContextManager::Result(startup_status_, startup_error_);

chrome/browser/chromeos/borealis/borealis_context_manager_impl.h

@@ -45,7 +45,7 @@ class BorealisContextManagerImpl : public BorealisContextManager {
   bool is_borealis_starting_ = false;
 
   Profile* profile_ = nullptr;
-  BorealisContextManager::Status startup_status_ = kSuccess;
+  BorealisContextManager::Status startup_status_ = Status::kSuccess;
   std::string startup_error_;
   BorealisContext context_;
   base::queue<ResultCallback> callback_queue_;

chrome/browser/chromeos/borealis/borealis_context_manager_unittest.cc

@@ -25,7 +25,8 @@ MATCHER(IsSuccessResult, "") {
 }
 
 MATCHER(IsFailureResult, "") {
-  return !arg.Ok() && arg.Failure() == BorealisContextManager::kStartVmFailed &&
+  return !arg.Ok() &&
+         arg.Failure() == BorealisContextManager::Status::kStartVmFailed &&
          arg.FailureReason() == "Something went wrong!";
 }
 
@@ -36,10 +37,10 @@ class MockTask : public BorealisTask {
            BorealisTask::CompletionStatusCallback callback) override {
     if (success_) {
       context->set_vm_name("test_vm_name");
-      std::move(callback).Run(BorealisContextManager::kSuccess, "");
+      std::move(callback).Run(BorealisContextManager::Status::kSuccess, "");
     } else {
       // Just use a random error.
-      std::move(callback).Run(BorealisContextManager::kStartVmFailed,
+      std::move(callback).Run(BorealisContextManager::Status::kStartVmFailed,
                               "Something went wrong!");
     }
   }

chrome/browser/chromeos/borealis/borealis_task.cc

@@ -35,11 +35,11 @@ void MountDlc::OnMountDlc(
     const chromeos::DlcserviceClient::InstallResult& install_result) {
   if (install_result.error != dlcservice::kErrorNone) {
     std::move(callback).Run(
-        BorealisContextManager::kMountFailed,
+        BorealisContextManager::Status::kMountFailed,
         "Mounting the DLC for Borealis failed: " + install_result.error);
   } else {
     context->set_root_path(install_result.root_path);
-    std::move(callback).Run(BorealisContextManager::kSuccess, "");
+    std::move(callback).Run(BorealisContextManager::Status::kSuccess, "");
   }
 }
 
@@ -69,7 +69,7 @@ void CreateDiskImage::OnCreateDiskImage(
   if (!response) {
     context->set_disk_path(base::FilePath());
     std::move(callback).Run(
-        BorealisContextManager::kDiskImageFailed,
+        BorealisContextManager::Status::kDiskImageFailed,
         "Failed to create disk image for Borealis: Empty response.");
     return;
   }
@@ -77,13 +77,13 @@ void CreateDiskImage::OnCreateDiskImage(
   if (response->status() != vm_tools::concierge::DISK_STATUS_EXISTS &&
       response->status() != vm_tools::concierge::DISK_STATUS_CREATED) {
     context->set_disk_path(base::FilePath());
-    std::move(callback).Run(BorealisContextManager::kDiskImageFailed,
+    std::move(callback).Run(BorealisContextManager::Status::kDiskImageFailed,
                             "Failed to create disk image for Borealis: " +
                                 response->failure_reason());
     return;
   }
   context->set_disk_path(base::FilePath(response->disk_path()));
-  std::move(callback).Run(BorealisContextManager::kSuccess, "");
+  std::move(callback).Run(BorealisContextManager::Status::kSuccess, "");
 }
 
 StartBorealisVm::StartBorealisVm() = default;
@@ -127,19 +127,19 @@ void StartBorealisVm::OnStartBorealisVm(
     CompletionStatusCallback callback,
     base::Optional<vm_tools::concierge::StartVmResponse> response) {
   if (!response) {
-    std::move(callback).Run(BorealisContextManager::kStartVmFailed,
+    std::move(callback).Run(BorealisContextManager::Status::kStartVmFailed,
                             "Failed to start Borealis VM: Empty response.");
     return;
   }
 
   if (response->status() == vm_tools::concierge::VM_STATUS_RUNNING ||
       response->status() == vm_tools::concierge::VM_STATUS_STARTING) {
-    std::move(callback).Run(BorealisContextManager::kSuccess, "");
+    std::move(callback).Run(BorealisContextManager::Status::kSuccess, "");
     return;
   }
 
   std::move(callback).Run(
-      BorealisContextManager::kStartVmFailed,
+      BorealisContextManager::Status::kStartVmFailed,
       "Failed to start Borealis VM: " + response->failure_reason() + " (code " +
           base::NumberToString(response->status()) + ")");
 }
@@ -165,11 +165,12 @@ void AwaitBorealisStartup::OnAwaitBorealisStartup(
     CompletionStatusCallback callback,
     base::Optional<std::string> container) {
   if (!container) {
-    std::move(callback).Run(BorealisContextManager::kAwaitBorealisStartupFailed,
+    std::move(callback).Run(
+        BorealisContextManager::Status::kAwaitBorealisStartupFailed,
         "Awaiting for Borealis launch failed: timed out");
     return;
   }
   context->set_container_name(container.value());
-  std::move(callback).Run(BorealisContextManager::kSuccess, "");
+  std::move(callback).Run(BorealisContextManager::Status::kSuccess, "");
 }
 }  // namespace borealis

chrome/browser/chromeos/borealis/borealis_task_unittest.cc

@@ -91,7 +91,7 @@ TEST_F(BorealisTasksTest, MountDlcSucceedsAndCallbackRanWithResults) {
   EXPECT_EQ(context_->root_path(), "");
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   MountDlc task;
   task.Run(context_.get(), callback.GetCallback());
@@ -109,7 +109,7 @@ TEST_F(BorealisTasksTest, CreateDiskSucceedsAndCallbackRanWithResults) {
   EXPECT_EQ(context_->disk_path(), base::FilePath());
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   CreateDiskImage task;
   task.Run(context_.get(), callback.GetCallback());
@@ -129,7 +129,7 @@ TEST_F(BorealisTasksTest,
   EXPECT_EQ(context_->disk_path(), base::FilePath());
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   CreateDiskImage task;
   task.Run(context_.get(), callback.GetCallback());
@@ -145,7 +145,7 @@ TEST_F(BorealisTasksTest, StartBorealisVmSucceedsAndCallbackRanWithResults) {
   fake_concierge_client_->set_start_vm_response(std::move(response));
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   StartBorealisVm task;
   task.Run(context_.get(), callback.GetCallback());
@@ -161,7 +161,7 @@ TEST_F(BorealisTasksTest,
   fake_concierge_client_->set_start_vm_response(std::move(response));
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   StartBorealisVm task;
   task.Run(context_.get(), callback.GetCallback());
@@ -179,7 +179,7 @@ TEST_F(BorealisTasksTest,
   signal.set_container_name("penguin");
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   AwaitBorealisStartup task(context_->profile(), context_->vm_name());
   task.Run(context_.get(), callback.GetCallback());
@@ -197,7 +197,7 @@ TEST_F(BorealisTasksTest,
   signal.set_container_name("penguin");
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback, Callback(BorealisContextManager::kSuccess, _));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kSuccess, _));
 
   AwaitBorealisStartup task(context_->profile(), context_->vm_name());
   fake_cicerone_client_->NotifyContainerStarted(std::move(signal));
@@ -210,7 +210,8 @@ TEST_F(BorealisTasksTest,
   testing::StrictMock<CallbackForTesting> callback;
   EXPECT_CALL(
       callback,
-      Callback(BorealisContextManager::kAwaitBorealisStartupFailed, StrNe("")));
+      Callback(BorealisContextManager::Status::kAwaitBorealisStartupFailed,
+               StrNe("")));
 
   AwaitBorealisStartup task(context_->profile(), context_->vm_name());
   task.GetWatcherForTesting().SetTimeoutForTesting(
@@ -225,8 +226,8 @@ class BorealisTasksTestDlc : public BorealisTasksTest,
 TEST_P(BorealisTasksTestDlc, MountDlcFailsAndCallbackRanWithResults) {
   fake_dlcservice_client_->set_install_error(GetParam());
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback,
-              Callback(BorealisContextManager::kMountFailed, StrNe("")));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kMountFailed,
+                                 StrNe("")));
 
   MountDlc task;
   task.Run(context_.get(), callback.GetCallback());
@@ -254,8 +255,9 @@ TEST_P(BorealisTasksTestDiskImage, CreateDiskFailsAndCallbackRanWithResults) {
   EXPECT_EQ(context_->disk_path(), base::FilePath());
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback,
-              Callback(BorealisContextManager::kDiskImageFailed, StrNe("")));
+  EXPECT_CALL(
+      callback,
+      Callback(BorealisContextManager::Status::kDiskImageFailed, StrNe("")));
 
   CreateDiskImage task;
   task.Run(context_.get(), callback.GetCallback());
@@ -286,8 +288,8 @@ TEST_P(BorealisTasksTestsStartBorealisVm,
   fake_concierge_client_->set_start_vm_response(std::move(response));
 
   testing::StrictMock<CallbackForTesting> callback;
-  EXPECT_CALL(callback,
-              Callback(BorealisContextManager::kStartVmFailed, StrNe("")));
+  EXPECT_CALL(callback, Callback(BorealisContextManager::Status::kStartVmFailed,
+                                 StrNe("")));
 
   StartBorealisVm task;
   task.Run(context_.get(), callback.GetCallback());