input/Plugin: pass URI as std::string_view

src/input/plugins/AlsaInputPlugin.cxx

@@ -90,7 +90,7 @@ public:
 	AlsaInputStream(const AlsaInputStream &) = delete;
 	AlsaInputStream &operator=(const AlsaInputStream &) = delete;
 
-	static InputStreamPtr Create(EventLoop &event_loop, const char *uri,
+	static InputStreamPtr Create(EventLoop &event_loop, std::string_view uri,
 				     Mutex &mutex);
 
 protected:
@@ -194,11 +194,9 @@ AlsaInputStream::AlsaInputStream(EventLoop &_loop,
 }
 
 inline InputStreamPtr
-AlsaInputStream::Create(EventLoop &event_loop, const char *uri,
+AlsaInputStream::Create(EventLoop &event_loop, std::string_view uri,
 			Mutex &mutex)
 {
-	assert(uri != nullptr);
-
 	AlsaInputStream::SourceSpec spec(uri);
 	if (!spec.IsValidScheme())
 		return nullptr;
@@ -451,7 +449,7 @@ alsa_input_init(EventLoop &event_loop, const ConfigBlock &block)
 }
 
 static InputStreamPtr
-alsa_input_open(const char *uri, Mutex &mutex)
+alsa_input_open(std::string_view uri, Mutex &mutex)
 {
 	return AlsaInputStream::Create(*global_config.event_loop, uri,
 				       mutex);

src/input/plugins/CdioParanoiaInputPlugin.cxx

@@ -47,7 +47,7 @@ class CdioParanoiaInputStream final : public InputStream {
 	lsn_t buffer_lsn;
 
  public:
-	CdioParanoiaInputStream(const char *_uri, Mutex &_mutex,
+	CdioParanoiaInputStream(std::string_view _uri, Mutex &_mutex,
 				cdrom_drive_t *_drv, CdIo_t *_cdio,
 				bool reverse_endian,
 				lsn_t _lsn_from, lsn_t lsn_to)
@@ -171,7 +171,7 @@ cdio_detect_device()
 }
 
 static InputStreamPtr
-input_cdio_open(const char *uri,
+input_cdio_open(std::string_view uri,
 		Mutex &mutex)
 {
 	const auto parsed_uri = parse_cdio_uri(uri);

src/input/plugins/CurlInputPlugin.cxx

@@ -19,9 +19,9 @@
 #include "lib/fmt/ToBuffer.hxx"
 #include "event/Call.hxx"
 #include "event/Loop.hxx"
-#include "util/ASCII.hxx"
 #include "util/CNumberParser.hxx"
 #include "util/Domain.hxx"
+#include "util/StringCompare.hxx"
 #include "Log.hxx"
 #include "PluginUnavailable.hxx"
 #include "config.h"
@@ -42,6 +42,8 @@
 
 #include <curl/curl.h>
 
+using std::string_view_literals::operator""sv;
+
 /**
  * Do not buffer more than this number of bytes.  It should be a
  * reasonable limit that doesn't make low-end machines suffer too
@@ -596,10 +598,10 @@ OpenCurlInputStream(std::string_view uri, const Curl::Headers &headers,
 }
 
 static InputStreamPtr
-input_curl_open(const char *url, Mutex &mutex)
+input_curl_open(std::string_view url, Mutex &mutex)
 {
-	if (!StringStartsWithCaseASCII(url, "http://") &&
-	    !StringStartsWithCaseASCII(url, "https://"))
+	if (!StringStartsWithIgnoreCase(url, "http://"sv) &&
+	    !StringStartsWithIgnoreCase(url, "https://"sv))
 		return nullptr;
 
 	return CurlInputStream::Open(url, {}, mutex);

src/input/plugins/FfmpegInputPlugin.cxx

@@ -18,7 +18,7 @@ class FfmpegInputStream final : public ThreadInputStream {
 	Ffmpeg::IOContext io;
 
 public:
-	FfmpegInputStream(const char *_uri, Mutex &_mutex)
+	FfmpegInputStream(std::string_view _uri, Mutex &_mutex)
 		:ThreadInputStream("ffmpeg", _uri, _mutex, BUFFER_SIZE)
 	{
 		Start();
@@ -82,8 +82,7 @@ input_ffmpeg_protocols() noexcept
 }
 
 static InputStreamPtr
-input_ffmpeg_open(const char *uri,
-		  Mutex &mutex)
+input_ffmpeg_open(std::string_view uri, Mutex &mutex)
 {
 	return std::make_unique<FfmpegInputStream>(uri, mutex);
 }

src/input/plugins/MmsInputPlugin.cxx

@@ -16,7 +16,7 @@ class MmsInputStream final : public ThreadInputStream {
 	mmsx_t *mms;
 
 public:
-	MmsInputStream(const char *_uri, Mutex &_mutex)
+	MmsInputStream(std::string_view _uri, Mutex &_mutex)
 		:ThreadInputStream(input_plugin_mms.name, _uri, _mutex,
 				   BUFFER_SIZE)
 	{
@@ -56,8 +56,7 @@ MmsInputStream::Open()
 }
 
 static InputStreamPtr
-input_mms_open(const char *url,
-	       Mutex &mutex)
+input_mms_open(std::string_view url, Mutex &mutex)
 {
 	return std::make_unique<MmsInputStream>(url, mutex);
 }

src/input/plugins/NfsInputPlugin.cxx

@@ -213,7 +213,7 @@ input_nfs_finish() noexcept
 }
 
 static InputStreamPtr
-input_nfs_open(const char *uri,
+input_nfs_open(std::string_view uri,
 	       Mutex &mutex)
 {
 	auto is = std::make_unique<NfsInputStream>(uri, mutex);

src/input/plugins/QobuzInputPlugin.cxx

@@ -17,6 +17,8 @@
 
 #include <memory>
 
+using std::string_view_literals::operator""sv;
+
 static QobuzClient *qobuz_client;
 
 class QobuzInputStream final
@@ -29,7 +31,7 @@ class QobuzInputStream final
 	std::exception_ptr error;
 
 public:
-	QobuzInputStream(const char *_uri, const char *_track_id,
+	QobuzInputStream(std::string_view _uri, std::string_view _track_id,
 			 Mutex &_mutex) noexcept
 		:ProxyInputStream(_uri, _mutex),
 		 track_id(_track_id)
@@ -151,27 +153,23 @@ FinishQobuzInput() noexcept
 }
 
 [[gnu::pure]]
-static const char *
-ExtractQobuzTrackId(const char *uri)
+static std::string_view 
+ExtractQobuzTrackId(std::string_view uri) noexcept
 {
 	// TODO: what's the standard "qobuz://" URI syntax?
-	const char *track_id = StringAfterPrefix(uri, "qobuz://track/");
-	if (track_id == nullptr)
-		return nullptr;
+	if (SkipPrefix(uri, "qobuz://track/"sv))
+		return uri;
 
-	if (*track_id == 0)
-		return nullptr;
-
-	return track_id;
+	return {};
 }
 
 static InputStreamPtr
-OpenQobuzInput(const char *uri, Mutex &mutex)
+OpenQobuzInput(std::string_view uri, Mutex &mutex)
 {
 	assert(qobuz_client != nullptr);
 
-	const char *track_id = ExtractQobuzTrackId(uri);
-	if (track_id == nullptr)
+	const auto track_id = ExtractQobuzTrackId(uri);
+	if (track_id.empty())
 		return nullptr;
 
 	// TODO: validate track_id
@@ -180,12 +178,12 @@ OpenQobuzInput(const char *uri, Mutex &mutex)
 }
 
 static std::unique_ptr<RemoteTagScanner>
-ScanQobuzTags(const char *uri, RemoteTagHandler &handler)
+ScanQobuzTags(std::string_view uri, RemoteTagHandler &handler)
 {
 	assert(qobuz_client != nullptr);
 
-	const char *track_id = ExtractQobuzTrackId(uri);
-	if (track_id == nullptr)
+	const auto track_id = ExtractQobuzTrackId(uri);
+	if (track_id.empty())
 		return nullptr;
 
 	return std::make_unique<QobuzTagScanner>(*qobuz_client, track_id,

src/input/plugins/QobuzTagScanner.cxx

@@ -61,16 +61,16 @@ public:
 };
 
 static std::string
-MakeTrackUrl(QobuzClient &client, const char *track_id)
+MakeTrackUrl(QobuzClient &client, std::string_view track_id)
 {
 	return client.MakeUrl("track", "get",
 			      {
-				      {"track_id", track_id},
+				      {"track_id", std::string{track_id}},
 			      });
 }
 
 QobuzTagScanner::QobuzTagScanner(QobuzClient &client,
-				 const char *track_id,
+				 std::string_view track_id,
 				 RemoteTagHandler &_handler)
 	:request(client.GetCurl(),
 		 MakeTrackUrl(client, track_id).c_str(),

src/input/plugins/QobuzTagScanner.hxx

@@ -21,7 +21,7 @@ public:
 	class ResponseParser;
 
 	QobuzTagScanner(QobuzClient &client,
-			const char *track_id,
+			std::string_view track_id,
 			RemoteTagHandler &_handler);
 
 	~QobuzTagScanner() noexcept override;

src/input/plugins/SmbclientInputPlugin.cxx

@@ -17,7 +17,7 @@ class SmbclientInputStream final : public InputStream {
 	SMBCFILE *const handle;
 
 public:
-	SmbclientInputStream(const char *_uri,
+	SmbclientInputStream(std::string &&_uri,
 			     Mutex &_mutex,
 			     SmbclientContext &&_ctx,
 			     SMBCFILE *_handle, const struct stat &st)
@@ -64,12 +64,13 @@ input_smbclient_init(EventLoop &, const ConfigBlock &)
 }
 
 static InputStreamPtr
-input_smbclient_open(const char *uri,
+input_smbclient_open(std::string_view _uri,
 		     Mutex &mutex)
 {
 	auto ctx = SmbclientContext::New();
 
-	SMBCFILE *handle = ctx.OpenReadOnly(uri);
+	std::string uri{_uri};
+	SMBCFILE *handle = ctx.OpenReadOnly(uri.c_str());
 	if (handle == nullptr)
 		throw MakeErrno("smbc_open() failed");
 
@@ -81,7 +82,7 @@ input_smbclient_open(const char *uri,
 	}
 
 	return std::make_unique<MaybeBufferedInputStream>
-		(std::make_unique<SmbclientInputStream>(uri, mutex,
+		(std::make_unique<SmbclientInputStream>(std::move(uri), mutex,
 							std::move(ctx),
 							handle, st));
 }