Merge branch 'websockets_namespace' of https://git01.codeplex.com/forks/stevetgates/stgatesdev into websockets_namespace

Conflicts:
	Release/include/cpprest/ws_client.h
	Release/include/cpprest/ws_msg.h
	Release/src/websockets/client/ws_winrt.cpp

Author: stgates

Release/include/cpprest/ws_client.h

@@ -57,6 +57,9 @@ namespace web
 /// WebSocket client is currently in beta.
 namespace experimental 
 {
+// In the past namespace was accidentally called 'web_sockets'. To avoid breaking code
+// alias it. At our next major release this should be deleted.
+namespace web_sockets = websockets;
 namespace websockets
 {
 /// WebSocket client side library.

Release/include/cpprest/ws_msg.h

@@ -59,8 +59,10 @@ namespace client
 namespace details
 {
     class winrt_client;
-    class ReceiveContext;
     class ws_desktop_client;
+#if defined(__cplusplus_winrt)
+    ref class ReceiveContext;
+#endif
 }
 
 /// <summary>
@@ -92,6 +94,8 @@ class _websocket_message
 
     websocket_message_type message_type() const { return m_msg_type; }
 
+    websocket_message_type message_type() const { return m_msg_type; }
+
 private:
 
     websocket_message_type m_msg_type;
@@ -265,8 +269,10 @@ class websocket_incoming_message
 private:
     friend class details::winrt_client;
     friend class details::ws_desktop_client;
-    friend class details::ReceiveContext;
-    
+#if defined(__cplusplus_winrt)
+    friend ref class details::ReceiveContext;
+#endif
+
     // Store message body in a container buffer backed by a string.
     // Allows for optimization in the string message cases.
     concurrency::streams::container_buffer<std::string> m_body;

Release/src/websockets/client/ws_winrt.cpp

@@ -61,7 +61,7 @@ ref class ReceiveContext sealed
 
 private:
     // Public members cannot have native types
-    ReceiveContext(std::function<void(websocket_incoming_message &>)> receive_handler, std::function<void()> close_handler): m_receive_handler(receive_handler), m_close_handler(close_handler) {}
+    ReceiveContext(std::function<void(websocket_incoming_message &)> receive_handler, std::function<void()> close_handler): m_receive_handler(receive_handler), m_close_handler(close_handler) {}
 
     // Handler to be executed when a message has been received by the client
     std::function<void(websocket_incoming_message &)> m_receive_handler;
@@ -246,13 +246,13 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
                 m_outgoing_msg_queue.push(msg);
             }
         }
-        return pplx::create_task(msg._m_impl->msg_sent());
+        return pplx::create_task(msg.body_sent());
     }
 
     void send_msg(websocket_outgoing_message &msg)
     {
         auto this_client = this->shared_from_this();
-        auto& is_buf = msg.m_body.create_istream();
+        auto &is_buf = msg.m_body;
         auto length = msg._m_impl->length();
 
         if (length == SIZE_MAX)
@@ -264,7 +264,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
                 auto buf_sz = is_buf.size();
                 if (buf_sz >= SIZE_MAX)
                 {
-                    msg.signal_msg_sent(std::make_exception_ptr(websocket_exception("Cannot send messages larger than SIZE_MAX.")));
+                    msg.signal_body_sent(std::make_exception_ptr(websocket_exception("Cannot send messages larger than SIZE_MAX.")));
                     return;
                 }
                 length = static_cast<size_t>(buf_sz);
@@ -275,7 +275,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
                 // The stream needs to be buffered.
                 auto is_buf_istream = is_buf.create_istream();
                 msg.m_body = concurrency::streams::container_buffer<std::vector<uint8_t>>();
-                is_buf_istream.read_to_end(msg.m_body).then([this_client, msg](pplx::task<size_t> t)
+                is_buf_istream.read_to_end(msg.m_body).then([this_client, msg](pplx::task<size_t> t) mutable
                 {
                     try
                     {
@@ -284,7 +284,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
                     }
                     catch (...)
                     {
-                        msg.signal_msg_sent(std::current_exception());
+                        msg.signal_body_sent(std::current_exception());
                     }
                 });
                 // We have postponed the call to send_msg() until after the data is buffered.
@@ -334,7 +334,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
 
             // Send the data as one complete message, in WinRT we do not have an option to send fragments.
             return pplx::task<unsigned int>(this_client->m_messageWriter->StoreAsync());
-        }).then([this_client, msg, is_buf, acquired, sp_allocated, length](pplx::task<unsigned int> previousTask)
+        }).then([this_client, msg, is_buf, acquired, sp_allocated, length](pplx::task<unsigned int> previousTask) mutable
         {
             std::exception_ptr eptr;
             unsigned int bytes_written = 0;
@@ -364,7 +364,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
             // Set the send_task_completion_event after calling release.
             if (eptr)
             {
-                msg.signal_msg_sent(eptr);
+                msg.signal_body_sent(eptr);
             }
 
             {
@@ -377,7 +377,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
                     this_client->send_msg(next_msg);
                 }
             }
-            msg.signal_msg_sent();
+            msg.signal_body_sent();
         });
     }
 
@@ -462,7 +462,7 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
 void ReceiveContext::OnReceive(MessageWebSocket^ sender, MessageWebSocketMessageReceivedEventArgs^ args)
 {
     websocket_incoming_message ws_incoming_message;
-    auto &msg = ws_incoming_message->_m_impl;
+    auto &msg = ws_incoming_message._m_impl;
 
     switch(args->MessageType)
     {
@@ -478,11 +478,14 @@ void ReceiveContext::OnReceive(MessageWebSocket^ sender, MessageWebSocketMessage
     {
         DataReader^ reader = args->GetDataReader();
         const auto len = reader->UnconsumedBufferLength;
-        std::string payload;
-        payload.resize(len);
-        reader->ReadBytes(Platform::ArrayReference<uint8_t>(payload.c_str(), len));
-        ws_incoming_message.m_body = concurrency::streams::container_buffer<std::string>(std::move(payload));
-        msg->signal_msg_received(len);
+        if (len > 0)
+        {
+            std::string payload;
+            payload.resize(len);
+            reader->ReadBytes(Platform::ArrayReference<uint8_t>(reinterpret_cast<uint8 *>(&payload[0]), len));
+            ws_incoming_message.m_body = concurrency::streams::container_buffer<std::string>(std::move(payload));
+        }
+        msg->set_length(len);
         m_receive_handler(ws_incoming_message);
     }
     catch(...)