Merge changes Id4934af4,Iadab40b4 am: f1cf1e8ccf

Original change: https://android-review.googlesource.com/c/device/google/cuttlefish/+/2465233

Change-Id: I75c5055f2b1da39f4bd0f59a21f2fd2ff14c4925
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

7 files changed, 110 insertions, 119 deletions

diff --git a/host/commands/cvd/Android.bp b/host/commands/cvd/Android.bp
index d4dcb4087..6d19fbff9 100644
--- a/host/commands/cvd/Android.bp
+++ b/host/commands/cvd/Android.bp
@@ -95,6 +95,7 @@ cc_library_host_static {
         "command_sequence.cpp",
         "common_utils.cpp",
         "demo_multi_vd.cpp",
+        "flag.cpp",
         "frontline_parser.cpp",
         "epoll_loop.cpp",
         "handle_reset.cpp",
diff --git a/host/commands/cvd/flag.cpp b/host/commands/cvd/flag.cpp
new file mode 100644
index 000000000..ca86a8d85
--- /dev/null
+++ b/host/commands/cvd/flag.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "host/commands/cvd/flag.h"
+
+#include "host/commands/cvd/common_utils.h"
+
+namespace cuttlefish {
+
+Result<std::string> CvdFlagProxy::Name() const {
+  CF_EXPECT(GetType() != FlagType::kUnknown, "Unsupported flag type");
+  auto decode_name = Overload{
+      [](auto&& param) -> std::string { return param.Name(); },
+  };
+  return std::visit(decode_name, flag_);
+}
+
+CvdFlagProxy::FlagType CvdFlagProxy::GetType() const {
+  auto decode_type = Overload{
+      [](const CvdFlag<bool>&) -> FlagType { return FlagType::kBool; },
+      [](const CvdFlag<std::int32_t>&) -> FlagType { return FlagType::kInt32; },
+      [](const CvdFlag<std::string>&) -> FlagType { return FlagType::kString; },
+      [](auto) -> FlagType { return FlagType::kUnknown; },
+  };
+  return std::visit(decode_type, flag_);
+}
+
+Result<bool> CvdFlagProxy::HasDefaultValue() const {
+  CF_EXPECT(GetType() != FlagType::kUnknown, "Unsupported flag type of typeid");
+  auto decode_default_value = Overload{
+      [](auto&& flag) -> bool { return flag.HasDefaultValue(); },
+  };
+  return std::visit(decode_default_value, flag_);
+}
+
+std::vector<CvdFlagProxy> FlagCollection::Flags() const {
+  std::vector<CvdFlagProxy> flags;
+  flags.reserve(name_flag_map_.size());
+  for (const auto& [name, flag] : name_flag_map_) {
+    flags.push_back(flag);
+  }
+  return flags;
+}
+
+}  // namespace cuttlefish
diff --git a/host/commands/cvd/selector/flag.h b/host/commands/cvd/flag.h
index 958598320..2863864e1 100644
--- a/host/commands/cvd/selector/flag.h
+++ b/host/commands/cvd/flag.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <functional>
 #include <optional>
 #include <string>
@@ -29,29 +30,28 @@
 #include "host/commands/cvd/types.h"
 
 namespace cuttlefish {
-namespace selector {
 
 /**
- * Data structure to represent user-facing flags
+ * Data structure to represent cvd user-facing flags
  *
  * Flag in flag_parser.h is more on parsing. gflags library would be
- * slowly depreicated. The SelectorFlag is a specification for
+ * slowly depreicated. The cvd driver and selector flags are a specification for
  * a user-facing flag.
  */
 template <typename T>
-class SelectorFlag {
+class CvdFlag {
  public:
-  SelectorFlag(const std::string& name) : name_(name) {}
+  CvdFlag(const std::string& name) : name_(name) {}
 
-  SelectorFlag(const std::string& name, const T& default_value)
+  CvdFlag(const std::string& name, const T& default_value)
       : name_(name), default_value_(default_value) {}
   std::string Name() const { return name_; }
   std::string HelpMessage() const { return help_msg_; }
-  SelectorFlag& SetHelpMessage(const std::string& help_msg) & {
+  CvdFlag& SetHelpMessage(const std::string& help_msg) & {
     help_msg_ = help_msg;
     return *this;
   }
-  SelectorFlag SetHelpMessage(const std::string& help_msg) && {
+  CvdFlag SetHelpMessage(const std::string& help_msg) && {
     help_msg_ = help_msg;
     return *this;
   }
@@ -95,21 +95,27 @@ class SelectorFlag {
   std::optional<T> default_value_;
 };
 
-class SelectorFlagProxy {
+class CvdFlagProxy {
   friend class FlagCollection;
 
  public:
+  enum class FlagType : std::uint32_t {
+    kUnknown = 0,
+    kBool,
+    kInt32,
+    kString,
+  };
   template <typename T>
-  SelectorFlagProxy(SelectorFlag<T>&& flag) : flag_{std::move(flag)} {}
+  CvdFlagProxy(CvdFlag<T>&& flag) : flag_{std::move(flag)} {}
 
   template <typename T>
-  const SelectorFlag<T>* GetFlag() const {
-    return std::get_if<SelectorFlag<T>>(&flag_);
+  const CvdFlag<T>* GetFlag() const {
+    return std::get_if<CvdFlag<T>>(&flag_);
   }
 
   template <typename T>
-  SelectorFlag<T>* GetFlag() {
-    return std::get_if<SelectorFlag<T>>(&flag_);
+  CvdFlag<T>* GetFlag() {
+    return std::get_if<CvdFlag<T>>(&flag_);
   }
 
   /*
@@ -120,11 +126,13 @@ class SelectorFlagProxy {
   Result<std::string> Name() const;
   Result<bool> HasDefaultValue() const;
 
+  FlagType GetType() const;
+
   template <typename T>
   Result<T> DefaultValue() const {
     const bool has_default_value = CF_EXPECT(HasDefaultValue());
     CF_EXPECT(has_default_value == true);
-    const auto* ptr = CF_EXPECT(std::get_if<SelectorFlag<T>>(&flag_));
+    const auto* ptr = CF_EXPECT(std::get_if<CvdFlag<T>>(&flag_));
     CF_EXPECT(ptr != nullptr);
     return ptr->DefaultValue();
   }
@@ -134,7 +142,7 @@ class SelectorFlagProxy {
   template <typename T>
   Result<void> FilterFlag(cvd_common::Args& args, std::optional<T>& output) {
     output = std::nullopt;
-    auto* ptr = CF_EXPECT(std::get_if<SelectorFlag<T>>(&flag_));
+    auto* ptr = CF_EXPECT(std::get_if<CvdFlag<T>>(&flag_));
     CF_EXPECT(ptr != nullptr);
     output = CF_EXPECT(ptr->FilterFlag(args));
     return {};
@@ -146,41 +154,40 @@ class SelectorFlagProxy {
   Result<void> ParseFlag(cvd_common::Args& args, T& output) {
     bool has_default_value = CF_EXPECT(HasDefaultValue());
     CF_EXPECT(has_default_value == true);
-    auto* ptr = CF_EXPECT(std::get_if<SelectorFlag<T>>(&flag_));
+    auto* ptr = CF_EXPECT(std::get_if<CvdFlag<T>>(&flag_));
     CF_EXPECT(ptr != nullptr);
     output = CF_EXPECT(ptr->ParseFlag(args));
     return {};
   }
 
  private:
-  std::variant<SelectorFlag<std::int32_t>, SelectorFlag<bool>,
-               SelectorFlag<std::string>>
+  std::variant<CvdFlag<std::int32_t>, CvdFlag<bool>, CvdFlag<std::string>>
       flag_;
 };
 
 class FlagCollection {
  public:
   template <typename T>
-  Result<void> EnrollFlag(SelectorFlag<T>&& flag) {
+  Result<void> EnrollFlag(CvdFlag<T>&& flag) {
     CF_EXPECT(!Contains(name_flag_map_, flag.Name()),
               flag.Name() << " is already registered.");
-    name_flag_map_.emplace(flag.Name(), SelectorFlagProxy(std::move(flag)));
+    const auto name = flag.Name();
+    name_flag_map_.emplace(name, CvdFlagProxy(std::move(flag)));
     return {};
   }
 
-  Result<SelectorFlagProxy> GetFlag(const std::string& name) const {
+  Result<CvdFlagProxy> GetFlag(const std::string& name) const {
     const auto itr = name_flag_map_.find(name);
     CF_EXPECT(itr != name_flag_map_.end(),
               "Flag \"" << name << "\" is not found.");
-    const SelectorFlagProxy& flag_proxy = itr->second;
+    const CvdFlagProxy& flag_proxy = itr->second;
     return flag_proxy;
   }
 
-  std::vector<SelectorFlagProxy> Flags() const;
+  std::vector<CvdFlagProxy> Flags() const;
 
  private:
-  std::unordered_map<std::string, SelectorFlagProxy> name_flag_map_;
+  std::unordered_map<std::string, CvdFlagProxy> name_flag_map_;
 };
 
-}  // namespace selector
 }  // namespace cuttlefish
diff --git a/host/commands/cvd/selector/Android.bp b/host/commands/cvd/selector/Android.bp
index 9fa465ba2..3d24b9965 100644
--- a/host/commands/cvd/selector/Android.bp
+++ b/host/commands/cvd/selector/Android.bp
@@ -24,7 +24,6 @@ cc_library_host_static {
         "arguments_separator.cpp",
         "creation_analyzer.cpp",
         "device_selector_utils.cpp",
-        "flag.cpp",
         "group_selector.cpp",
         "instance_database.cpp",
         "instance_database_impl.cpp",
diff --git a/host/commands/cvd/selector/flag.cpp b/host/commands/cvd/selector/flag.cpp
deleted file mode 100644
index 231575872..000000000
--- a/host/commands/cvd/selector/flag.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "host/commands/cvd/selector/flag.h"
-
-#include "host/commands/cvd/common_utils.h"
-
-namespace cuttlefish {
-namespace selector {
-
-Result<std::string> SelectorFlagProxy::Name() const {
-  auto decoder = Overload{
-      [](const SelectorFlag<bool>& bool_flag) -> Result<std::string> {
-        return bool_flag.Name();
-      },
-      [](const SelectorFlag<std::int32_t>& int32_flag) -> Result<std::string> {
-        return int32_flag.Name();
-      },
-      [](const SelectorFlag<std::string>& string_flag) -> Result<std::string> {
-        return string_flag.Name();
-      },
-      [](auto) -> Result<std::string> {
-        return CF_ERR("The type is not handled by SelectorFlagProxy");
-      },
-  };
-  auto name = CF_EXPECT(std::visit(decoder, flag_));
-  return name;
-}
-
-Result<bool> SelectorFlagProxy::HasDefaultValue() const {
-  auto decoder = Overload{
-      [](const SelectorFlag<bool>& bool_flag) -> Result<bool> {
-        return bool_flag.HasDefaultValue();
-      },
-      [](const SelectorFlag<std::int32_t>& int32_flag) -> Result<bool> {
-        return int32_flag.HasDefaultValue();
-      },
-      [](const SelectorFlag<std::string>& string_flag) -> Result<bool> {
-        return string_flag.HasDefaultValue();
-      },
-      [](auto) -> Result<bool> {
-        return CF_ERR("The type is not handled by SelectorFlagProxy");
-      },
-  };
-  auto has_default_value = CF_EXPECT(std::visit(decoder, flag_));
-  return has_default_value;
-}
-
-std::vector<SelectorFlagProxy> FlagCollection::Flags() const {
-  std::vector<SelectorFlagProxy> flags;
-  flags.reserve(name_flag_map_.size());
-  for (const auto& [name, flag] : name_flag_map_) {
-    flags.push_back(flag);
-  }
-  return flags;
-}
-
-}  // namespace selector
-}  // namespace cuttlefish
diff --git a/host/commands/cvd/selector/selector_constants.cpp b/host/commands/cvd/selector/selector_constants.cpp
index 02c800959..3cdb6ad24 100644
--- a/host/commands/cvd/selector/selector_constants.cpp
+++ b/host/commands/cvd/selector/selector_constants.cpp
@@ -126,9 +126,8 @@ Result<std::string> ParentOfAutogeneratedHomes(const uid_t client_uid,
   return CF_ERR("Tried all candidate directories but none was read-writable.");
 }
 
-SelectorFlag<std::string> SelectorFlags::GroupNameFlag(
-    const std::string& name) {
-  SelectorFlag<std::string> group_name{name};
+CvdFlag<std::string> SelectorFlags::GroupNameFlag(const std::string& name) {
+  CvdFlag<std::string> group_name{name};
   std::stringstream group_name_help;
   group_name_help << "--" << name << "=<"
                   << "name of the instance group>";
@@ -136,9 +135,8 @@ SelectorFlag<std::string> SelectorFlags::GroupNameFlag(
   return group_name;
 }
 
-SelectorFlag<std::string> SelectorFlags::InstanceNameFlag(
-    const std::string& name) {
-  SelectorFlag<std::string> instance_name{name};
+CvdFlag<std::string> SelectorFlags::InstanceNameFlag(const std::string& name) {
+  CvdFlag<std::string> instance_name{name};
   std::stringstream instance_name_help;
   instance_name_help << "--" << name << "=<"
                      << "comma-separated names of the instances>";
@@ -146,18 +144,18 @@ SelectorFlag<std::string> SelectorFlags::InstanceNameFlag(
   return instance_name;
 }
 
-SelectorFlag<bool> SelectorFlags::DisableDefaultGroupFlag(
-    const std::string& name, const bool default_val) {
-  SelectorFlag<bool> disable_default_group(name, default_val);
+CvdFlag<bool> SelectorFlags::DisableDefaultGroupFlag(const std::string& name,
+                                                     const bool default_val) {
+  CvdFlag<bool> disable_default_group(name, default_val);
   std::stringstream help;
   help << "--" << name << "=true not to create the default instance group.";
   disable_default_group.SetHelpMessage(help.str());
   return disable_default_group;
 }
 
-SelectorFlag<bool> SelectorFlags::AcquireFileLockFlag(const std::string& name,
-                                                      const bool default_val) {
-  SelectorFlag<bool> acquire_file_lock(name, default_val);
+CvdFlag<bool> SelectorFlags::AcquireFileLockFlag(const std::string& name,
+                                                 const bool default_val) {
+  CvdFlag<bool> acquire_file_lock(name, default_val);
   std::stringstream help;
   help << "--" << name
        << "=false for cvd server not to acquire lock file locks.";
diff --git a/host/commands/cvd/selector/selector_constants.h b/host/commands/cvd/selector/selector_constants.h
index f655ad806..c17532372 100644
--- a/host/commands/cvd/selector/selector_constants.h
+++ b/host/commands/cvd/selector/selector_constants.h
@@ -21,7 +21,7 @@
 #include <string>
 
 #include "common/libs/utils/result.h"
-#include "host/commands/cvd/selector/flag.h"
+#include "host/commands/cvd/flag.h"
 
 namespace cuttlefish {
 namespace selector {
@@ -71,7 +71,7 @@ class SelectorFlags {
   static constexpr char kDisableDefaultGroup[] = "disable_default_group";
   static const SelectorFlags& Get();
 
-  Result<SelectorFlagProxy> GetFlag(const std::string& search_key) const {
+  Result<CvdFlagProxy> GetFlag(const std::string& search_key) const {
     auto flag = CF_EXPECT(flags_.GetFlag(search_key));
     return flag;
   }
@@ -84,12 +84,12 @@ class SelectorFlags {
     flags_.EnrollFlag(AcquireFileLockFlag(kAcquireFileLock, true));
   }
 
-  SelectorFlag<std::string> GroupNameFlag(const std::string& name);
-  SelectorFlag<std::string> InstanceNameFlag(const std::string& name);
-  SelectorFlag<bool> DisableDefaultGroupFlag(const std::string& name,
-                                             const bool default_val);
-  SelectorFlag<bool> AcquireFileLockFlag(const std::string& name,
-                                         const bool default_val);
+  CvdFlag<std::string> GroupNameFlag(const std::string& name);
+  CvdFlag<std::string> InstanceNameFlag(const std::string& name);
+  CvdFlag<bool> DisableDefaultGroupFlag(const std::string& name,
+                                        const bool default_val);
+  CvdFlag<bool> AcquireFileLockFlag(const std::string& name,
+                                    const bool default_val);
 
   FlagCollection flags_;
 };