Use unsigned for instance ids everywhere

Author: jemoreira

base/cvd/cuttlefish/host/commands/cvd/instances/lock/instance_lock.cpp

@@ -34,10 +34,10 @@
 
 namespace cuttlefish {
 
-InstanceLockFile::InstanceLockFile(LockFile&& lock_file, const int instance_num)
+InstanceLockFile::InstanceLockFile(LockFile&& lock_file, const unsigned instance_num)
     : lock_file_(std::move(lock_file)), instance_num_(instance_num) {}
 
-int InstanceLockFile::Instance() const { return instance_num_; }
+unsigned InstanceLockFile::Instance() const { return instance_num_; }
 
 Result<InUseState> InstanceLockFile::Status() const {
   auto in_use_state = CF_EXPECT(lock_file_.Status());
@@ -53,22 +53,22 @@ InstanceLockFileManager::InstanceLockFileManager(
     std::string instance_locks_path)
     : instance_locks_path_(std::move(instance_locks_path)) {};
 
-Result<std::string> InstanceLockFileManager::LockFilePath(int instance_num) {
+Result<std::string> InstanceLockFileManager::LockFilePath(unsigned instance_num) {
   std::stringstream path;
   path << instance_locks_path_;
   CF_EXPECT(EnsureDirectoryExists(path.str()));
   path << "local-instance-" << instance_num << ".lock";
   return path.str();
 }
 
-Result<void> InstanceLockFileManager::RemoveLockFile(int instance_num) {
+Result<void> InstanceLockFileManager::RemoveLockFile(unsigned instance_num) {
   const auto lock_file_path = CF_EXPECT(LockFilePath(instance_num));
   CF_EXPECT(RemoveFile(lock_file_path), StrError(errno));
   return {};
 }
 
 Result<InstanceLockFile> InstanceLockFileManager::AcquireUnusedLock() {
-  for (int i = 1;; i++) {
+  for (unsigned i = 1;; i++) {
     auto lock = CF_EXPECT(TryAcquireLock(i));
     if (lock && CF_EXPECT(lock->Status()) == InUseState::kNotInUse) {
       return *lock;
@@ -77,15 +77,15 @@ Result<InstanceLockFile> InstanceLockFileManager::AcquireUnusedLock() {
 }
 
 Result<InstanceLockFile> InstanceLockFileManager::AcquireLock(
-    int instance_num) {
+    unsigned instance_num) {
   const auto lock_file_path = CF_EXPECT(LockFilePath(instance_num));
   LockFile lock_file =
       CF_EXPECT(lock_file_manager_.AcquireLock(lock_file_path));
   return InstanceLockFile(std::move(lock_file), instance_num);
 }
 
 Result<std::optional<InstanceLockFile>> InstanceLockFileManager::TryAcquireLock(
-    int instance_num) {
+    unsigned instance_num) {
   const auto lock_file_path = CF_EXPECT(LockFilePath(instance_num));
   std::optional<LockFile> lock_file_opt =
       CF_EXPECT(lock_file_manager_.TryAcquireLock(lock_file_path));

base/cvd/cuttlefish/host/commands/cvd/instances/lock/instance_lock.h

@@ -28,14 +28,14 @@ class InstanceLockFile {
   using LockFile = cvd_impl::LockFile;
 
  public:
-  int Instance() const;
+  unsigned Instance() const;
   Result<InUseState> Status() const;
   Result<void> Status(InUseState);
 
  private:
-  InstanceLockFile(LockFile&& lock_file, int instance_num);
+  InstanceLockFile(LockFile&& lock_file, unsigned instance_num);
   LockFile lock_file_;
-  const int instance_num_;
+  const unsigned instance_num_;
 };
 
 class InstanceLockFileManager {
@@ -45,17 +45,17 @@ class InstanceLockFileManager {
  public:
   InstanceLockFileManager(std::string instance_locks_path);
 
-  Result<InstanceLockFile> AcquireLock(int instance_num);
+  Result<InstanceLockFile> AcquireLock(unsigned instance_num);
   Result<InstanceLockFile> AcquireUnusedLock();
 
   // TODO: This routine should  be removed and replaced with allocd
   // The caller must check if the instance_num belongs to the user, before
   // calling this. It is a quick fix for b/316824572
-  Result<void> RemoveLockFile(int instance_num);
+  Result<void> RemoveLockFile(unsigned instance_num);
 
  private:
-  Result<std::string> LockFilePath(int instance_num);
-  Result<std::optional<InstanceLockFile>> TryAcquireLock(int instance_num);
+  Result<std::string> LockFilePath(unsigned instance_num);
+  Result<std::optional<InstanceLockFile>> TryAcquireLock(unsigned instance_num);
 
   std::string instance_locks_path_;
   LockFileManager lock_file_manager_;