Merge pull request #8154 from lioncash/analytics

{Common/Analytics, Core/Analytics}: Minor C++17 transitional changes

2 files changed, 20 insertions, 16 deletions

diff --git a/Source/Core/Common/Analytics.cpp b/Source/Core/Common/Analytics.cpp
index 4441e9a7df..63903767ba 100644
--- a/Source/Core/Common/Analytics.cpp
+++ b/Source/Core/Common/Analytics.cpp
@@ -76,15 +76,19 @@ AnalyticsReportBuilder::AnalyticsReportBuilder()
   m_report.push_back(WIRE_FORMAT_VERSION);
 }
 
-void AnalyticsReportBuilder::AppendSerializedValue(std::string* report, const std::string& v)
+void AnalyticsReportBuilder::AppendSerializedValue(std::string* report, std::string_view v)
 {
   AppendType(report, TypeId::STRING);
   AppendBytes(report, reinterpret_cast<const u8*>(v.data()), static_cast<u32>(v.size()));
 }
 
+// We can't remove this overload despite the string_view overload due to the fact that
+// pointers can implicitly convert to bool, so if we removed the overload, then all
+// const char strings passed in would begin forwarding to the bool overload,
+// which is definitely not what we want to occur.
 void AnalyticsReportBuilder::AppendSerializedValue(std::string* report, const char* v)
 {
-  AppendSerializedValue(report, std::string(v));
+  AppendSerializedValue(report, std::string_view(v));
 }
 
 void AnalyticsReportBuilder::AppendSerializedValue(std::string* report, bool v)
@@ -198,7 +202,7 @@ void StdoutAnalyticsBackend::Send(std::string report)
          HexDump(reinterpret_cast<const u8*>(report.data()), report.size()).c_str());
 }
 
-HttpAnalyticsBackend::HttpAnalyticsBackend(const std::string& endpoint) : m_endpoint(endpoint)
+HttpAnalyticsBackend::HttpAnalyticsBackend(std::string endpoint) : m_endpoint(std::move(endpoint))
 {
 }
 
diff --git a/Source/Core/Common/Analytics.h b/Source/Core/Common/Analytics.h
index 4930ef4763..a14150e21c 100644
--- a/Source/Core/Common/Analytics.h
+++ b/Source/Core/Common/Analytics.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <string_view>
 #include <thread>
 #include <utility>
 #include <vector>
@@ -46,7 +47,7 @@ namespace Common
 class AnalyticsReportingBackend
 {
 public:
-  virtual ~AnalyticsReportingBackend() {}
+  virtual ~AnalyticsReportingBackend() = default;
   // Called from the AnalyticsReporter backend thread.
   virtual void Send(std::string report) = 0;
 };
@@ -61,7 +62,7 @@ public:
   AnalyticsReportBuilder(const AnalyticsReportBuilder& other) { *this = other; }
   AnalyticsReportBuilder(AnalyticsReportBuilder&& other)
   {
-    std::lock_guard<std::mutex> lk(other.m_lock);
+    std::lock_guard lk{other.m_lock};
     m_report = std::move(other.m_report);
   }
 
@@ -69,8 +70,7 @@ public:
   {
     if (this != &other)
     {
-      std::lock_guard<std::mutex> lk(m_lock);
-      std::lock_guard<std::mutex> lk2(other.m_lock);
+      std::scoped_lock lk{m_lock, other.m_lock};
       m_report = other.m_report;
     }
     return *this;
@@ -81,24 +81,24 @@ public:
   {
     // Get before locking the object to avoid deadlocks with this += this.
     std::string other_report = other.Get();
-    std::lock_guard<std::mutex> lk(m_lock);
+    std::lock_guard lk{m_lock};
     m_report += other_report;
     return *this;
   }
 
   template <typename T>
-  AnalyticsReportBuilder& AddData(const std::string& key, const T& value)
+  AnalyticsReportBuilder& AddData(std::string_view key, const T& value)
   {
-    std::lock_guard<std::mutex> lk(m_lock);
+    std::lock_guard lk{m_lock};
     AppendSerializedValue(&m_report, key);
     AppendSerializedValue(&m_report, value);
     return *this;
   }
 
   template <typename T>
-  AnalyticsReportBuilder& AddData(const std::string& key, const std::vector<T>& value)
+  AnalyticsReportBuilder& AddData(std::string_view key, const std::vector<T>& value)
   {
-    std::lock_guard<std::mutex> lk(m_lock);
+    std::lock_guard lk{m_lock};
     AppendSerializedValue(&m_report, key);
     AppendSerializedValueVector(&m_report, value);
     return *this;
@@ -106,19 +106,19 @@ public:
 
   std::string Get() const
   {
-    std::lock_guard<std::mutex> lk(m_lock);
+    std::lock_guard lk{m_lock};
     return m_report;
   }
 
   // More efficient version of Get().
   std::string Consume()
   {
-    std::lock_guard<std::mutex> lk(m_lock);
+    std::lock_guard lk{m_lock};
     return std::move(m_report);
   }
 
 protected:
-  static void AppendSerializedValue(std::string* report, const std::string& v);
+  static void AppendSerializedValue(std::string* report, std::string_view v);
   static void AppendSerializedValue(std::string* report, const char* v);
   static void AppendSerializedValue(std::string* report, bool v);
   static void AppendSerializedValue(std::string* report, u64 v);
@@ -185,7 +185,7 @@ public:
 class HttpAnalyticsBackend : public AnalyticsReportingBackend
 {
 public:
-  HttpAnalyticsBackend(const std::string& endpoint);
+  explicit HttpAnalyticsBackend(std::string endpoint);
   ~HttpAnalyticsBackend() override;
 
   void Send(std::string report) override;