[LLDB][GUI] Add Process Plugin Field

[OmarEmaraDev]

Summary

This patch adds a new Process Plugin Field. It is a choices field that
lists all the available process plugins and can retrieve the name of the
selected plugin or an empty string if the default is selected.

The Attach form now uses that field instead of manually creating a
choices field.

lldb/source/Core/IOHandlerCursesGUI.cpp

protected:
   int m_number_of_visible_choices;
   std::vector<std::string> m_choices;
   // The index of the selected choice.
   int m_choice;
   // The index of the first visible choice in the field.
   int m_first_visibile_choice;
 };
 
+class ProcessPluginFieldDelegate : public ChoicesFieldDelegate {
+public:
+  ProcessPluginFieldDelegate()
+      : ChoicesFieldDelegate("Process Plugin", 3, GetPossiblePluginNames()) {}
+
+  std::vector<std::string> GetPossiblePluginNames() {
+    std::vector<std::string> names;
+    names.push_back("<default>");
+
+    size_t i = 0;
+    while (auto name = PluginManager::GetProcessPluginNameAtIndex(i++))
+      names.push_back(name);
+    return names;
+  }
+
+  std::string GetPluginName() {
+    std::string plugin_name = GetChoiceContent();
+    if (plugin_name == "<default>")
+      return "";
+    return plugin_name;
+  }
+};
+
 template <class T> class ListFieldDelegate : public FieldDelegate {
 public:
   ListFieldDelegate(const char *label, T default_field)
       : m_label(label), m_default_field(default_field), m_selection_index(0),
         m_selection_type(SelectionType::NewButton) {}
 
   // Signify which element is selected. If a field or a remove button is
   // selected, then m_selection_index signifies the particular field that
public:
   ChoicesFieldDelegate *AddChoicesField(const char *label, int height,
                                         std::vector<std::string> choices) {
     ChoicesFieldDelegate *delegate =
         new ChoicesFieldDelegate(label, height, choices);
     m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
+  ProcessPluginFieldDelegate *AddProcessPluginField() {
+    ProcessPluginFieldDelegate *delegate = new ProcessPluginFieldDelegate();
+    m_fields.push_back(FieldDelegateUP(delegate));
+    return delegate;
+  }
+
   template <class T>
   ListFieldDelegate<T> *AddListField(const char *label, T default_field) {
     ListFieldDelegate<T> *delegate =
         new ListFieldDelegate<T>(label, default_field);
     m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
ProcessAttachFormDelegate(Debugger &debugger, WindowSP main_window_sp)
     m_pid_field = AddIntegerField("PID", 0);
     m_name_field =
         AddTextField("Process Name", GetDefaultProcessName().c_str());
     m_continue_field = AddBooleanField("Continue once attached.", false);
     m_wait_for_field = AddBooleanField("Wait for process to launch.", false);
     m_include_existing_field =
         AddBooleanField("Include existing processes.", false);
     m_show_advanced_field = AddBooleanField("Show advanced settings.", false);
-    m_plugin_field =
-        AddChoicesField("Plugin Name", 3, GetPossiblePluginNames());
+    m_plugin_field = AddProcessPluginField();
 
     AddAction("Attach", [this](Window &window) { Attach(window); });
   }
 
   std::string GetName() override { return "Attach Process"; }
 
   void UpdateFieldsVisibility() override {
     if (m_type_field->GetChoiceContent() == "Name") {
std::string GetDefaultProcessName() {
 
     ModuleSP module_sp = target->GetExecutableModule();
     if (!module_sp->IsExecutable())
       return "";
 
     return module_sp->GetFileSpec().GetFilename().AsCString();
   }
 
-  std::vector<std::string> GetPossiblePluginNames() {
-    std::vector<std::string> names;
-    names.push_back("<default>");
-
-    size_t i = 0;
-    while (auto name = PluginManager::GetProcessPluginNameAtIndex(i++))
-      names.push_back(name);
-    return names;
-  }
-
   bool StopRunningProcess() {
     ExecutionContext exe_ctx =
         m_debugger.GetCommandInterpreter().GetExecutionContext();
 
     if (!exe_ctx.HasProcessScope())
       return false;
 
     Process *process = exe_ctx.GetProcessPtr();
if (m_type_field->GetChoiceContent() == "Name") {
       attach_info.GetExecutableFile().SetFile(m_name_field->GetText(),
                                               FileSpec::Style::native);
       attach_info.SetWaitForLaunch(m_wait_for_field->GetBoolean());
       if (m_wait_for_field->GetBoolean())
         attach_info.SetIgnoreExisting(!m_include_existing_field->GetBoolean());
     } else {
       attach_info.SetProcessID(m_pid_field->GetInteger());
     }
-    if (m_plugin_field->GetChoiceContent() != "<default>")
-      attach_info.SetProcessPluginName(m_plugin_field->GetChoiceContent());
+    attach_info.SetProcessPluginName(m_plugin_field->GetPluginName());
 
     return attach_info;
   }
 
   void Attach(Window &window) {
     ClearError();
 
     bool process_is_running = StopRunningProcess();
protected:
 
   ChoicesFieldDelegate *m_type_field;
   IntegerFieldDelegate *m_pid_field;
   TextFieldDelegate *m_name_field;
   BooleanFieldDelegate *m_continue_field;
   BooleanFieldDelegate *m_wait_for_field;
   BooleanFieldDelegate *m_include_existing_field;
   BooleanFieldDelegate *m_show_advanced_field;
-  ChoicesFieldDelegate *m_plugin_field;
+  ProcessPluginFieldDelegate *m_plugin_field;
 };
 
 class MenuDelegate {
 public:
   virtual ~MenuDelegate() = default;
 
   virtual MenuActionResult MenuDelegateAction(Menu &menu) = 0;
 };