Merge branch 'master' of https://github.com/jasjuang/vcpkg

1 files changed, 80 insertions, 78 deletions

diff --git a/toolsrc/src/metrics.cpp b/toolsrc/src/metrics.cpp
index 7992f3e51..8a0050bfc 100644
--- a/toolsrc/src/metrics.cpp
+++ b/toolsrc/src/metrics.cpp
@@ -8,6 +8,8 @@
 
 namespace vcpkg::Metrics
 {
+    Util::LockGuarded<Metrics> g_metrics;
+
     static std::string get_current_date_time()
     {
         struct tm newtime;
@@ -18,12 +20,12 @@ namespace vcpkg::Metrics
 
         _ftime_s(&timebuffer);
         time_t now = timebuffer.time;
-        int milli = timebuffer.millitm;
+        const int milli = timebuffer.millitm;
 
-        errno_t err = gmtime_s(&newtime, &now);
+        const errno_t err = gmtime_s(&newtime, &now);
         if (err)
         {
-            return "";
+            return Strings::EMPTY;
         }
 
         strftime(&date[0], date.size(), "%Y-%m-%dT%H:%M:%S", &newtime);
@@ -32,7 +34,7 @@ namespace vcpkg::Metrics
 
     static std::string generate_random_UUID()
     {
-        int partSizes[] = {8, 4, 4, 4, 12};
+        int part_sizes[] = {8, 4, 4, 4, 12};
         char uuid[37];
         memset(uuid, 0, sizeof(uuid));
         int num;
@@ -48,7 +50,7 @@ namespace vcpkg::Metrics
 
             // Generating UUID format version 4
             // http://en.wikipedia.org/wiki/Universally_unique_identifier
-            for (int i = 0; i < partSizes[part]; i++, index++)
+            for (int i = 0; i < part_sizes[part]; i++, index++)
             {
                 if (part == 2 && i == 0)
                 {
@@ -79,8 +81,8 @@ namespace vcpkg::Metrics
 
     static const std::string& get_session_id()
     {
-        static const std::string id = generate_random_UUID();
-        return id;
+        static const std::string ID = generate_random_UUID();
+        return ID;
     }
 
     static std::string to_json_string(const std::string& str)
@@ -99,11 +101,11 @@ namespace vcpkg::Metrics
             else if (ch < 0x20 || ch >= 0x80)
             {
                 // Note: this treats incoming Strings as Latin-1
-                static constexpr const char hex[16] = {
+                static constexpr const char HEX[16] = {
                     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
                 encoded.append("\\u00");
-                encoded.push_back(hex[ch / 16]);
-                encoded.push_back(hex[ch % 16]);
+                encoded.push_back(HEX[ch / 16]);
+                encoded.push_back(HEX[ch % 16]);
             }
             else
             {
@@ -118,21 +120,21 @@ namespace vcpkg::Metrics
     {
         std::wstring path;
         path.resize(MAX_PATH);
-        auto n = GetSystemDirectoryW(&path[0], static_cast<UINT>(path.size()));
+        const auto n = GetSystemDirectoryW(&path[0], static_cast<UINT>(path.size()));
         path.resize(n);
         path += L"\\kernel32.dll";
 
-        auto versz = GetFileVersionInfoSizeW(path.c_str(), nullptr);
-        if (versz == 0) return "";
+        const auto versz = GetFileVersionInfoSizeW(path.c_str(), nullptr);
+        if (versz == 0) return Strings::EMPTY;
 
         std::vector<char> verbuf;
         verbuf.resize(versz);
 
-        if (!GetFileVersionInfoW(path.c_str(), 0, static_cast<DWORD>(verbuf.size()), &verbuf[0])) return "";
+        if (!GetFileVersionInfoW(path.c_str(), 0, static_cast<DWORD>(verbuf.size()), &verbuf[0])) return Strings::EMPTY;
 
         void* rootblock;
         UINT rootblocksize;
-        if (!VerQueryValueW(&verbuf[0], L"\\", &rootblock, &rootblocksize)) return "";
+        if (!VerQueryValueW(&verbuf[0], L"\\", &rootblock, &rootblocksize)) return Strings::EMPTY;
 
         auto rootblock_ffi = static_cast<VS_FIXEDFILEINFO*>(rootblock);
 
@@ -150,7 +152,7 @@ namespace vcpkg::Metrics
         std::string properties;
         std::string measurements;
 
-        void TrackProperty(const std::string& name, const std::string& value)
+        void track_property(const std::string& name, const std::string& value)
         {
             if (properties.size() != 0) properties.push_back(',');
             properties.append(to_json_string(name));
@@ -158,7 +160,7 @@ namespace vcpkg::Metrics
             properties.append(to_json_string(value));
         }
 
-        void TrackMetric(const std::string& name, double value)
+        void track_metric(const std::string& name, double value)
         {
             if (measurements.size() != 0) measurements.push_back(',');
             measurements.append(to_json_string(name));
@@ -223,25 +225,25 @@ namespace vcpkg::Metrics
         return hkcu_sqmclient.value_or(L"{}");
     }
 
-    void set_user_information(const std::string& user_id, const std::string& first_use_time)
+    void Metrics::set_user_information(const std::string& user_id, const std::string& first_use_time)
     {
         g_metricmessage.user_id = user_id;
         g_metricmessage.user_timestamp = first_use_time;
     }
 
-    void init_user_information(std::string& user_id, std::string& first_use_time)
+    void Metrics::init_user_information(std::string& user_id, std::string& first_use_time)
     {
         user_id = generate_random_UUID();
         first_use_time = get_current_date_time();
     }
 
-    void set_send_metrics(bool should_send_metrics) { g_should_send_metrics = should_send_metrics; }
+    void Metrics::set_send_metrics(bool should_send_metrics) { g_should_send_metrics = should_send_metrics; }
 
-    void set_print_metrics(bool should_print_metrics) { g_should_print_metrics = should_print_metrics; }
+    void Metrics::set_print_metrics(bool should_print_metrics) { g_should_print_metrics = should_print_metrics; }
 
-    void track_metric(const std::string& name, double value) { g_metricmessage.TrackMetric(name, value); }
+    void Metrics::track_metric(const std::string& name, double value) { g_metricmessage.track_metric(name, value); }
 
-    void track_property(const std::string& name, const std::wstring& value)
+    void Metrics::track_property(const std::string& name, const std::wstring& value)
     {
         // Note: this is not valid UTF-16 -> UTF-8, it just yields a close enough approximation for our purposes.
         std::string converted_value;
@@ -249,85 +251,85 @@ namespace vcpkg::Metrics
         std::transform(
             value.begin(), value.end(), converted_value.begin(), [](wchar_t ch) { return static_cast<char>(ch); });
 
-        g_metricmessage.TrackProperty(name, converted_value);
+        g_metricmessage.track_property(name, converted_value);
     }
 
-    void track_property(const std::string& name, const std::string& value)
+    void Metrics::track_property(const std::string& name, const std::string& value)
     {
-        g_metricmessage.TrackProperty(name, value);
+        g_metricmessage.track_property(name, value);
     }
 
-    void upload(const std::string& payload)
+    void Metrics::upload(const std::string& payload)
     {
-        HINTERNET hSession = nullptr, hConnect = nullptr, hRequest = nullptr;
-        BOOL bResults = FALSE;
+        HINTERNET connect = nullptr, request = nullptr;
+        BOOL results = FALSE;
 
-        hSession = WinHttpOpen(
+        const HINTERNET session = WinHttpOpen(
             L"vcpkg/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
-        if (hSession)
-            hConnect = WinHttpConnect(hSession, L"dc.services.visualstudio.com", INTERNET_DEFAULT_HTTPS_PORT, 0);
-
-        if (hConnect)
-            hRequest = WinHttpOpenRequest(hConnect,
-                                          L"POST",
-                                          L"/v2/track",
-                                          nullptr,
-                                          WINHTTP_NO_REFERER,
-                                          WINHTTP_DEFAULT_ACCEPT_TYPES,
-                                          WINHTTP_FLAG_SECURE);
-
-        if (hRequest)
+        if (session) connect = WinHttpConnect(session, L"dc.services.visualstudio.com", INTERNET_DEFAULT_HTTPS_PORT, 0);
+
+        if (connect)
+            request = WinHttpOpenRequest(connect,
+                                         L"POST",
+                                         L"/v2/track",
+                                         nullptr,
+                                         WINHTTP_NO_REFERER,
+                                         WINHTTP_DEFAULT_ACCEPT_TYPES,
+                                         WINHTTP_FLAG_SECURE);
+
+        if (request)
         {
             if (MAXDWORD <= payload.size()) abort();
             std::wstring hdrs = L"Content-Type: application/json\r\n";
-            bResults = WinHttpSendRequest(hRequest,
-                                          hdrs.c_str(),
-                                          static_cast<DWORD>(hdrs.size()),
-                                          (void*)&payload[0],
-                                          static_cast<DWORD>(payload.size()),
-                                          static_cast<DWORD>(payload.size()),
-                                          0);
+            std::string& p = const_cast<std::string&>(payload);
+            results = WinHttpSendRequest(request,
+                                         hdrs.c_str(),
+                                         static_cast<DWORD>(hdrs.size()),
+                                         static_cast<void*>(&p[0]),
+                                         static_cast<DWORD>(payload.size()),
+                                         static_cast<DWORD>(payload.size()),
+                                         0);
         }
 
-        if (bResults)
+        if (results)
         {
-            bResults = WinHttpReceiveResponse(hRequest, nullptr);
+            results = WinHttpReceiveResponse(request, nullptr);
         }
 
         DWORD http_code = 0, junk = sizeof(DWORD);
 
-        if (bResults)
+        if (results)
         {
-            bResults = WinHttpQueryHeaders(hRequest,
-                                           WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
-                                           nullptr,
-                                           &http_code,
-                                           &junk,
-                                           WINHTTP_NO_HEADER_INDEX);
+            results = WinHttpQueryHeaders(request,
+                                          WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
+                                          nullptr,
+                                          &http_code,
+                                          &junk,
+                                          WINHTTP_NO_HEADER_INDEX);
         }
 
-        std::vector<char> responseBuffer;
-        if (bResults)
+        std::vector<char> response_buffer;
+        if (results)
         {
-            DWORD availableData = 0, readData = 0, totalData = 0;
-            while ((bResults = WinHttpQueryDataAvailable(hRequest, &availableData)) == TRUE && availableData > 0)
+            DWORD available_data = 0, read_data = 0, total_data = 0;
+            while ((results = WinHttpQueryDataAvailable(request, &available_data)) == TRUE && available_data > 0)
             {
-                responseBuffer.resize(responseBuffer.size() + availableData);
+                response_buffer.resize(response_buffer.size() + available_data);
 
-                bResults = WinHttpReadData(hRequest, &responseBuffer.data()[totalData], availableData, &readData);
+                results = WinHttpReadData(request, &response_buffer.data()[total_data], available_data, &read_data);
 
-                if (!bResults)
+                if (!results)
                 {
                     break;
                 }
 
-                totalData += readData;
+                total_data += read_data;
 
-                responseBuffer.resize(totalData);
+                response_buffer.resize(total_data);
             }
         }
 
-        if (!bResults)
+        if (!results)
         {
 #ifndef NDEBUG
             __debugbreak();
@@ -336,22 +338,22 @@ namespace vcpkg::Metrics
 #endif
         }
 
-        if (hRequest) WinHttpCloseHandle(hRequest);
-        if (hConnect) WinHttpCloseHandle(hConnect);
-        if (hSession) WinHttpCloseHandle(hSession);
+        if (request) WinHttpCloseHandle(request);
+        if (connect) WinHttpCloseHandle(connect);
+        if (session) WinHttpCloseHandle(session);
     }
 
     static fs::path get_bindir()
     {
         wchar_t buf[_MAX_PATH];
-        int bytes = GetModuleFileNameW(nullptr, buf, _MAX_PATH);
+        const int bytes = GetModuleFileNameW(nullptr, buf, _MAX_PATH);
         if (bytes == 0) std::abort();
         return fs::path(buf, buf + bytes);
     }
 
-    void flush()
+    void Metrics::flush()
     {
-        std::string payload = g_metricmessage.format_event_data_template();
+        const std::string payload = g_metricmessage.format_event_data_template();
         if (g_should_print_metrics) std::cerr << payload << "\n";
         if (!g_should_send_metrics) return;
 
@@ -375,7 +377,7 @@ namespace vcpkg::Metrics
                 path = vcpkgdir / "scripts" / "vcpkgmetricsuploader.exe";
                 if (fs.exists(path)) return path;
 
-                return L"";
+                return Strings::WEMPTY;
             }();
 
             std::error_code ec;
@@ -386,8 +388,8 @@ namespace vcpkg::Metrics
         const fs::path vcpkg_metrics_txt_path = temp_folder_path / ("vcpkg" + generate_random_UUID() + ".txt");
         fs.write_contents(vcpkg_metrics_txt_path, payload);
 
-        const std::wstring cmdLine =
+        const std::wstring cmd_line =
             Strings::wformat(L"start %s %s", temp_folder_path_exe.native(), vcpkg_metrics_txt_path.native());
-        System::cmd_execute_clean(cmdLine);
+        System::cmd_execute_clean(cmd_line);
     }
 }