Added winrt implementation as well + fixed dev11 issues with new tests

Author: ras0219-msft

Release/src/websockets/client/ws_winrt.cpp

@@ -230,9 +230,9 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
             return pplx::task_from_exception<void>(websocket_exception(_XPLATSTR("Cannot send empty message.")));
         }
 
-        if (length > UINT_MAX)
+        if (length >= UINT_MAX && length != SIZE_MAX)
         {
-            return pplx::task_from_exception<void>(websocket_exception(_XPLATSTR("Message size too large. Ensure message length is less than or equal to UINT_MAX.")));
+            return pplx::task_from_exception<void>(websocket_exception(_XPLATSTR("Message size too large. Ensure message length is less than UINT_MAX.")));
         }
 
         {
@@ -257,6 +257,47 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
         auto& is_buf = msg._m_impl->streambuf();
         auto length = msg._m_impl->length();
 
+        if (length == SIZE_MAX)
+        {
+            // This indicates we should determine the length automatically.
+            if (is_buf.has_size())
+            {
+                // The user's stream knows how large it is -- there's no need to buffer.
+                auto buf_sz = is_buf.size();
+                if (buf_sz >= SIZE_MAX)
+                {
+                    websocket_exception wx(_XPLATSTR("Cannot send messages larger than SIZE_MAX."));
+                    msg.m_send_tce.set_exception(std::make_exception_ptr(wx));
+                    return;
+                }
+                length = static_cast<size_t>(buf_sz);
+                // We have determined the length and can proceed normally.
+            }
+            else
+            {
+                // The stream needs to be buffered.
+                concurrency::streams::container_buffer<std::vector<uint8_t>> stbuf;
+                auto is_buf_istream = is_buf.create_istream();
+                msg._m_impl->set_streambuf(stbuf);
+                is_buf_istream.read_to_end(stbuf).then([this_client, msg](pplx::task<size_t> t)
+                {
+                    try
+                    {
+                        auto sz = t.get();
+                        msg._m_impl->set_length(sz);
+                        this_client->send_msg(msg);
+                    }
+                    catch (...)
+                    {
+                        auto eptr = std::current_exception();
+                        msg.m_send_tce.set_exception(eptr);
+                    }
+                });
+                // We have postponed the call to send_msg() until after the data is buffered.
+                return;
+            }
+        }
+
         // First try to acquire the data (Get a pointer to the next already allocated contiguous block of data)
         // If acquire succeeds, send the data over the socket connection, there is no copy of data from stream to temporary buffer.
         // If acquire fails, copy the data to a temporary buffer managed by sp_allocated and send it over the socket connection. 

Release/tests/Functional/websockets/client/send_msg_tests.cpp

@@ -424,9 +424,10 @@ TEST_FIXTURE(uri_address, send_stream_binary_msg_no_length)
 {
     test_websocket_server server;
 
-    std::vector<uint8_t> body = { { 0, 1, 2, 0 } };
+    std::string body = "\x00\x01\x02\x00";
+    std::vector<uint8_t> msgbuf(body.begin(), body.end());
 
-    auto is = streams::container_stream<std::vector<uint8_t>>::open_istream(body);
+    auto is = streams::container_stream<std::vector<uint8_t>>::open_istream(std::move(msgbuf));
 
     websocket_client client;
     {