[lldb][NFCI] Remove ConstString from Process::ConfigureStructuredData

[bulbazord]

Summary

This is a follow-up to b4827a3c0a7ef121ca376713e115b04eff0f5194.

lldb/include/lldb/Target/Process.h

void PruneThreadPlans();
   ///     to process.  The feature will dictate whether this is a dictionary,
   ///     an array or some other object.  If the feature needs to be
   ///     set up properly before it can be enabled, then the config should
   ///     also take an enable/disable flag.
   ///
   /// \return
   ///     Returns the result of attempting to configure the feature.
   virtual Status
-  ConfigureStructuredData(ConstString type_name,
+  ConfigureStructuredData(llvm::StringRef type_name,
                           const StructuredData::ObjectSP &config_sp);
 
   /// Broadcasts the given structured data object from the given plugin.
   ///
   /// StructuredDataPlugin instances can use this to optionally broadcast any
   /// of their data if they want to make it available for clients.  The data
   /// will come in on the structured data event bit
   /// (eBroadcastBitStructuredData).

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
 
   void ModulesDidLoad(ModuleList &module_list) override;
 
   StructuredData::ObjectSP
   GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address,
                                  lldb::addr_t image_count) override;
 
   Status
-  ConfigureStructuredData(ConstString type_name,
+  ConfigureStructuredData(llvm::StringRef type_name,
                           const StructuredData::ObjectSP &config_sp) override;
 
   StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override;
 
   StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos(
       const std::vector<lldb::addr_t> &load_addresses) override;
 
   StructuredData::ObjectSP

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
         }
       }
     }
   }
   return object_sp;
 }
 
 Status ProcessGDBRemote::ConfigureStructuredData(
-    ConstString type_name, const StructuredData::ObjectSP &config_sp) {
+    llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp) {
   return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
 }
 
 // Establish the largest memory read/write payloads we should use. If the
 // remote stub has a max packet size, stay under that size.
 //
 // If the remote stub's max packet size is crazy large, use a reasonable
 // largeish default.

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

if (m_enable) {
       // results in a scenario where no errors occur, but no logging is
       // captured, either.  This step is to eliminate that possibility.
       plugin.AddInitCompletionHook(*process_sp);
     }
 
     // Send configuration to the feature by way of the process. Construct the
     // options we will use.
     auto config_sp = m_options_sp->BuildConfigurationData(m_enable);
-    const Status error = process_sp->ConfigureStructuredData(
-        ConstString(GetDarwinLogTypeName()), config_sp);
+    const Status error =
+        process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
 
     // Report results.
     if (!error.Success()) {
       result.AppendError(error.AsCString());
       // Our configuration failed, so we're definitely disabled.
       plugin.SetEnabled(false);
     } else {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
LLDB_LOGF(log,
               "build configuration data for enable options, skipping "
               "(process uid %u)",
               __FUNCTION__, process_sp->GetUniqueID());
     return;
   }
 
   // We can run it directly.
   // Send configuration to the feature by way of the process.
-  const Status error = process_sp->ConfigureStructuredData(
-      ConstString(GetDarwinLogTypeName()), config_sp);
+  const Status error =
+      process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp);
 
   // Report results.
   if (!error.Success()) {
     LLDB_LOGF(log,
               "StructuredDataDarwinLog::%s() "
               "ConfigureStructuredData() call failed "
               "(process uid %u): %s",
               __FUNCTION__, process_sp->GetUniqueID(), error.AsCString());

lldb/source/Target/Process.cpp

if (region_info.GetMapped() == MemoryRegionInfo::eYes) {
       // If we have non-address bits and some are set then the end
       // is at or beyond the end of mappable memory.
       !(abi && (abi->FixAnyAddress(range_end) != range_end)));
 
   return error;
 }
 
 Status
-Process::ConfigureStructuredData(ConstString type_name,
+Process::ConfigureStructuredData(llvm::StringRef type_name,
                                  const StructuredData::ObjectSP &config_sp) {
   // If you get this, the Process-derived class needs to implement a method to
   // enable an already-reported asynchronous structured data feature. See
   // ProcessGDBRemote for an example implementation over gdb-remote.
   return Status("unimplemented");
 }
 
 void Process::MapSupportedStructuredDataPlugins(