[lldb][NFCI] Remove use of ConstString from StructuredDataPlugin

[bulbazord]

Summary

The use of ConstString in StructuredDataPlugin is unneccessary as fast
comparisons are not neeeded for StructuredDataPlugins.

[clayborg]

Looks fine to me. I will let the owner of StructuredDataDarwinLog do the final approval.

[JDevlieghere]

LGTM

lldb/include/lldb/Target/Process.h

protected:
   ///     When non-null and pointing to a dictionary, the 'type'
   ///     key's string value is used to look up the plugin that
   ///     was registered for that structured data type.  It then
   ///     calls the following method on the StructuredDataPlugin
   ///     instance:
   ///
   ///     virtual void
   ///     HandleArrivalOfStructuredData(Process &process,
-  ///                                   ConstString type_name,
+  ///                                   llvm::StringRef type_name,
   ///                                   const StructuredData::ObjectSP
   ///                                   &object_sp)
   ///
   /// \return
   ///     True if the structured data was routed to a plugin; otherwise,
   ///     false.
   bool RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp);
 

lldb/include/lldb/Target/StructuredDataPlugin.h

public:
   /// created covering all of the mapped features for a given process.
   ///
   /// \param[in] type_name
   ///     The name of the feature tag supported by a process.
   ///     e.g. "darwin-log".
   ///
   /// \return
   ///     true if the plugin supports the feature; otherwise, false.
-  virtual bool SupportsStructuredDataType(ConstString type_name) = 0;
+  virtual bool SupportsStructuredDataType(llvm::StringRef type_name) = 0;
 
   /// Handle the arrival of asynchronous structured data from the process.
   ///
   /// When asynchronous structured data arrives from the process monitor,
   /// it is immediately delivered to the plugin mapped for that feature
   /// if one exists.  The structured data that arrives from a process
   /// monitor must be a dictionary, and it must have a string field named
   /// "type" that must contain the StructuredData feature name set as the
public:
   ///     under the string value with key "type".
   ///
   /// \param[in] object_sp
   ///     A shared pointer to the structured data that arrived.  This must
   ///     be a dictionary.  The only key required is the aforementioned
   ///     key named "type" that must be a string value containing the
   ///     structured data type name.
   virtual void
-  HandleArrivalOfStructuredData(Process &process, ConstString type_name,
+  HandleArrivalOfStructuredData(Process &process, llvm::StringRef type_name,
                                 const StructuredData::ObjectSP &object_sp) = 0;
 
   /// Get a human-readable description of the contents of the data.
   ///
   /// In command-line LLDB, this method will be called by the Debugger
   /// instance for each structured data event generated, and the output
   /// will be printed to the LLDB console.  If nothing is added to the stream,
   /// nothing will be printed; otherwise, a newline will be added to the end
public:
   ///
   /// This is a convenience method for plugins that can enable or disable
   /// their functionality.  It allows retrieval of this state without
   /// requiring a cast.
   ///
   /// \param[in] type_name
   ///     The name of the feature tag for the asynchronous structured data.
   ///     This is needed for plugins that support more than one feature.
-  virtual bool GetEnabled(ConstString type_name) const;
+  virtual bool GetEnabled(llvm::StringRef type_name) const;
 
   /// Allow the plugin to do work related to modules that loaded in the
   /// the corresponding process.
   ///
   /// This method defaults to doing nothing.  Plugins can override it
   /// if they have any behavior they want to enable/modify based on loaded
   /// modules.
   ///

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h

public:
   static bool IsEnabled();
 
   // PluginInterface API
 
   llvm::StringRef GetPluginName() override { return GetStaticPluginName(); }
 
   // StructuredDataPlugin API
 
-  bool SupportsStructuredDataType(ConstString type_name) override;
+  bool SupportsStructuredDataType(llvm::StringRef type_name) override;
 
   void HandleArrivalOfStructuredData(
-      Process &process, ConstString type_name,
+      Process &process, llvm::StringRef type_name,
       const StructuredData::ObjectSP &object_sp) override;
 
   Status GetDescription(const StructuredData::ObjectSP &object_sp,
                         lldb_private::Stream &stream) override;
 
-  bool GetEnabled(ConstString type_name) const override;
+  bool GetEnabled(llvm::StringRef type_name) const override;
 
   void ModulesDidLoad(Process &process, ModuleList &module_list) override;
 
   ~StructuredDataDarwinLog() override;
 
 private:
   // Private constructors
 

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

if (!process_sp) {
       stream.PutCString("Availability: unknown (requires process)\n");
       stream.PutCString("Enabled: not applicable "
                         "(requires process)\n");
     } else {
       auto plugin_sp =
           process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
       stream.Printf("Availability: %s\n",
                     plugin_sp ? "available" : "unavailable");
-      llvm::StringRef plugin_name = StructuredDataDarwinLog::GetStaticPluginName();
       const bool enabled =
-          plugin_sp ? plugin_sp->GetEnabled(ConstString(plugin_name)) : false;
+          plugin_sp ? plugin_sp->GetEnabled(
+                          StructuredDataDarwinLog::GetStaticPluginName())
+                    : false;
       stream.Printf("Enabled: %s\n", enabled ? "true" : "false");
     }
 
     // Display filter settings.
     DebuggerSP debugger_sp =
         GetCommandInterpreter().GetDebugger().shared_from_this();
     auto options_sp = GetGlobalEnableOptions(debugger_sp);
     if (!options_sp) {

 }
 
 #pragma mark -
 #pragma mark StructuredDataPlugin API
 
 // StructuredDataPlugin API
 
 bool StructuredDataDarwinLog::SupportsStructuredDataType(
-    ConstString type_name) {
+    llvm::StringRef type_name) {
   return type_name == GetDarwinLogTypeName();
 }
 
 void StructuredDataDarwinLog::HandleArrivalOfStructuredData(
-    Process &process, ConstString type_name,
+    Process &process, llvm::StringRef type_name,
     const StructuredData::ObjectSP &object_sp) {
   Log *log = GetLog(LLDBLog::Process);
   if (log) {
     StreamString json_stream;
     if (object_sp)
       object_sp->Dump(json_stream);
     else
       json_stream.PutCString("<null>");
     LLDB_LOGF(log, "StructuredDataDarwinLog::%s() called with json: %s",
               __FUNCTION__, json_stream.GetData());
   }
 
   // Ignore empty structured data.
   if (!object_sp) {
     LLDB_LOGF(log,
               "StructuredDataDarwinLog::%s() StructuredData object "
               "is null",
               __FUNCTION__);
     return;
   }
 
   // Ignore any data that isn't for us.
   if (type_name != GetDarwinLogTypeName()) {
-    LLDB_LOGF(log,
-              "StructuredDataDarwinLog::%s() StructuredData type "
-              "expected to be %s but was %s, ignoring",
-              __FUNCTION__, GetDarwinLogTypeName().str().c_str(),
-              type_name.AsCString());
+    LLDB_LOG(log,
+             "StructuredData type expected to be {0} but was {1}, ignoring",
+             GetDarwinLogTypeName(), type_name);
     return;
   }
 
   // Broadcast the structured data event if we have that enabled. This is the
   // way that the outside world (all clients) get access to this data.  This
   // plugin sets policy as to whether we do that.
   DebuggerSP debugger_sp = process.GetTarget().GetDebugger().shared_from_this();
   auto options_sp = GetGlobalEnableOptions(debugger_sp);
events->ForEach(
         HandleDisplayOfEvent(*event, stream);
         return true;
       });
 
   stream.Flush();
   return error;
 }
 
-bool StructuredDataDarwinLog::GetEnabled(ConstString type_name) const {
-  if (type_name.GetStringRef() == GetStaticPluginName())
+bool StructuredDataDarwinLog::GetEnabled(llvm::StringRef type_name) const {
+  if (type_name == GetStaticPluginName())
     return m_is_enabled;
-  else
-    return false;
 }
 
 void StructuredDataDarwinLog::SetEnabled(bool enabled) {
   m_is_enabled = enabled;
 }
 
 void StructuredDataDarwinLog::ModulesDidLoad(Process &process,
                                              ModuleList &module_list) {

lldb/source/Target/Process.cpp

if (!plugin_sp) {
       // This plugin doesn't think it can work with the process. Move on to the
       // next.
       continue;
     }
 
     // For any of the remaining type names, map any that this plugin supports.
     std::vector<llvm::StringRef> names_to_remove;
     for (llvm::StringRef type_name : type_names) {
-      if (plugin_sp->SupportsStructuredDataType(ConstString(type_name))) {
+      if (plugin_sp->SupportsStructuredDataType(type_name)) {
         m_structured_data_plugin_map.insert(
             std::make_pair(type_name, plugin_sp));
         names_to_remove.push_back(type_name);
         LLDB_LOG(log, "using plugin {0} for type name {1}",
                  plugin_sp->GetPluginName(), type_name);
       }
     }
 
bool Process::RouteAsyncStructuredData(
   // Check if there's a plugin registered for this type name.
   auto find_it = m_structured_data_plugin_map.find(type_name);
   if (find_it == m_structured_data_plugin_map.end()) {
     // We don't have a mapping for this structured data type.
     return false;
   }
 
   // Route the structured data to the plugin.
-  find_it->second->HandleArrivalOfStructuredData(*this, ConstString(type_name),
-                                                 object_sp);
+  find_it->second->HandleArrivalOfStructuredData(*this, type_name, object_sp);
   return true;
 }
 
 Status Process::UpdateAutomaticSignalFiltering() {
   // Default implementation does nothign.
   // No automatic signal filtering to speak of.
   return Status();
 }

lldb/source/Target/StructuredDataPlugin.cpp

 };
 }
 
 StructuredDataPlugin::StructuredDataPlugin(const ProcessWP &process_wp)
     : PluginInterface(), m_process_wp(process_wp) {}
 
 StructuredDataPlugin::~StructuredDataPlugin() = default;
 
-bool StructuredDataPlugin::GetEnabled(ConstString type_name) const {
+bool StructuredDataPlugin::GetEnabled(llvm::StringRef type_name) const {
   // By default, plugins are always enabled.  Plugin authors should override
   // this if there is an enabled/disabled state for their plugin.
   return true;
 }
 
 ProcessSP StructuredDataPlugin::GetProcess() const {
   return m_process_wp.lock();
 }