Misc improvements to websockets.

1. Rename namespace from 'web_sockets' to 'websockets' create alias to keep from breaking customers.
   Will be removed at next major release.
2. Deleted unnecessary move constructor and move assignment operator from
   websocket_client class.
3. Removed unnecessary storage of task completion event for sending messages from
   websocket_outgoing_message, moved instead to websocket_incoming_message.
4. Added overload to websocket_outgoing_message::set_utf8_message for r-value
   references and const reference instead of just taking by value and moving.
5. websocket_outgoing_message::extract_string() - in our implementation the
   string always arrives immediately and there was no need to use a
   task completion event, so I deleted it. Results in less code and storage space.
6. Removed unnecessary websocket_incoming_message::_prepare_to_receive_data() function.
7. Changed our websocket desktop implementation for incoming messages to construct
   a container_buffer backed by a std::string and move the raw std::string from websocketpp.
   This saves a data copy on all incoming messages and is less code.
8. Changed our winrt implementation for incoming messages to use a container_buffer backed by std::string.
9. We deliver incoming websocket messages to customers in two forms: UTF-8 string and binary stream.
   In all cases we control allocation of the underlying stream buffer being used. Previously we were using a producer_consumer_buffer.
   Due to changes #8 and #9 before the data is stored in a std::string. This allows an optimization in websocket_incoming_message::extract_string.
   We now move the std::string out of the buffer instead of doing an asychronous read. Also saves locking overhead from producer_consumer_buffer,
   which is thread safe. And less code!
10. Removed some unnecessary string conversions for constructing websocket_exceptions.
11. Replaced some uses of std::unique_lock with std::lock_guard.
12. Misc adding more comments, const to some APIs, passing by reference, make_unique, etc...

Author: stgates

Release/include/cpprest/web_utilities.h

@@ -37,7 +37,7 @@ namespace http { namespace client {
     class http_client_config;
 }}
 
-namespace experimental { namespace web_sockets { namespace client {
+namespace experimental { namespace websockets { namespace client {
     class websocket_client_config;
 }}}
 
@@ -75,7 +75,7 @@ class credentials
 private:
     friend class web::web_proxy;
     friend class web::http::client::http_client_config;
-    friend class web::experimental::web_sockets::client::websocket_client_config;
+    friend class web::experimental::websockets::client::websocket_client_config;
 
     credentials() : m_is_set(false) {}
 

Release/include/cpprest/ws_client.h

@@ -57,7 +57,12 @@ namespace web
 /// WebSocket client is currently in beta.
 namespace experimental 
 {
-namespace web_sockets
+
+// 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.
 namespace client
@@ -359,29 +364,10 @@ class websocket_client
     _ASYNCRTIMP websocket_client(websocket_client_config client_config);
 
     /// <summary>
+    /// Destructor
     /// </summary>
     ~websocket_client() { }
 
-    /// <summary>
-    /// Move constructor.
-    /// </summary>
-    websocket_client(websocket_client &&other) 
-        : m_client(std::move(other.m_client))
-    {
-    }
-
-    /// <summary>
-    /// Move assignment operator.
-    /// </summary>
-    websocket_client &operator=(websocket_client &&other)
-    {
-        if(this != &other)
-        {
-            m_client = std::move(other.m_client);
-        }
-        return *this;
-    }
-
     /// <summary>
     /// Connects to the remote network destination. The connect method initiates the websocket handshake with the 
     /// remote network destination, takes care of the protocol upgrade request.

Release/include/cpprest/ws_msg.h

@@ -33,7 +33,7 @@
 #include <limits>
 
 #include "cpprest/xxpublic.h"
-#include "cpprest/containerstream.h"
+#include "cpprest/producerconsumerstream.h"
 
 #if _NOT_PHONE8_
 #if defined(_MSC_VER) && (_MSC_VER >= 1800)
@@ -51,7 +51,7 @@ namespace web
 { 
 namespace experimental
 {
-namespace web_sockets
+namespace websockets
 {
 namespace client
 {
@@ -60,8 +60,11 @@ namespace details
 {
     class winrt_client;
     class ws_desktop_client;
-}
 
+#if defined(__cplusplus_winrt)
+    ref class ReceiveContext;
+#endif
+}
 
 /// <summary>
 /// The different types of websocket message.
@@ -83,47 +86,19 @@ namespace details
 class _websocket_message
 {
 public:
-    _ASYNCRTIMP void set_body(concurrency::streams::istream instream);
-
-    /// <summary>
-    /// Get the streambuf for the message
-    /// </summary>
-    concurrency::streams::streambuf<uint8_t>& streambuf() { return m_buf; }
-
-    /// <summary>
-    /// Set the streambuf for the message
-    /// </summary>
-    void set_streambuf(concurrency::streams::streambuf<uint8_t> buf) { m_buf = buf; }
 
     void set_msg_type(websocket_message_type msg_type) { m_msg_type = msg_type; }
 
     void set_length(size_t len) { m_length = len; }
 
-    size_t length() { return m_length; }
-
-    websocket_message_type message_type() { return m_msg_type; }
-
-    pplx::task_completion_event<void> _get_data_available()  { return m_data_available; }
-
-    void _set_data_available() { m_data_available.set(); }
+    size_t length() const { return m_length; }
 
-    _ASYNCRTIMP std::string _extract_string();
+    websocket_message_type message_type() const { return m_msg_type; }
 
-    /// <summary>
-    /// Prepare the message with an output stream to receive network data
-    /// </summary>
-    _ASYNCRTIMP void _prepare_to_receive_data();
-
-protected:
-
-    concurrency::streams::streambuf<uint8_t> m_buf;
+private:
 
     websocket_message_type m_msg_type;
-
     size_t m_length;
-
-    /// <summary> The TCE is used to signal the availability of the message body. </summary>
-    pplx::task_completion_event<void> m_data_available;
 };
 }
 
@@ -133,24 +108,36 @@ class _websocket_message
 class websocket_outgoing_message 
 {
 public:
-    websocket_outgoing_message()
-        : _m_impl(std::make_shared<details::_websocket_message>()) {}
+
+    /// <summary>
+    /// Creates an initially empty message for sending. 
+    /// </summary>
+    websocket_outgoing_message() : _m_impl(std::make_shared<details::_websocket_message>()) {}
 
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
     /// <param name="data">UTF-8 String containing body of the message.</param>
-    void set_utf8_message(std::string data)
+    void set_utf8_message(std::string &&data)
     {
         this->_set_message(std::move(data), websocket_message_type::text_message);
     }
 
+    /// <summary>
+    /// Sets a UTF-8 message as the message body.
+    /// </summary>
+    /// <param name="data">UTF-8 String containing body of the message.</param>
+    void set_utf8_message(const std::string &data)
+    {
+        this->_set_message(data, websocket_message_type::text_message);
+    }
+
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <remarks>Upon sending, the entire stream may be buffered to determine the length.</remarks>
-    void set_utf8_message(concurrency::streams::istream istream)
+    void set_utf8_message(const concurrency::streams::istream &istream)
     {
         this->_set_message(istream, SIZE_MAX, websocket_message_type::text_message);
     }
@@ -160,7 +147,7 @@ class websocket_outgoing_message
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <param name="len">number of bytes to send.</param>
-    void set_utf8_message(concurrency::streams::istream istream, size_t len)
+    void set_utf8_message(const concurrency::streams::istream &istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::text_message);
     }
@@ -170,7 +157,7 @@ class websocket_outgoing_message
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <param name="len">number of bytes to send.</param>
-    void set_binary_message(concurrency::streams::istream istream, size_t len)
+    void set_binary_message(const concurrency::streams::istream &istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::binary_message);
     }
@@ -180,34 +167,52 @@ class websocket_outgoing_message
     /// </summary>
     /// <param name="istream">casablanca input stream representing the body of the message.</param>
     /// <remarks>Upon sending, the entire stream may be buffered to determine the length.</remarks>
-    void set_binary_message(concurrency::streams::istream istream)
+    void set_binary_message(const concurrency::streams::istream &istream)
     {
         this->_set_message(istream, SIZE_MAX, websocket_message_type::binary_message);
     }
 
 private:
-
     friend class details::winrt_client;
     friend class details::ws_desktop_client;
 
     std::shared_ptr<details::_websocket_message> _m_impl;
 
-    void _set_message(std::string data, websocket_message_type msg_type)
+    pplx::task_completion_event<void> m_body_sent;
+    concurrency::streams::streambuf<uint8_t> m_body;
+
+    void signal_body_sent()
+    {
+        m_body_sent.set();
+    }
+
+    void signal_body_sent(const std::exception_ptr &e)
+    {
+        m_body_sent.set_exception(e);
+    }
+
+    pplx::task_completion_event<void> & body_sent() { return m_body_sent; }
+
+    void _set_message(std::string &&data, websocket_message_type msg_type)
     {
         _m_impl->set_msg_type(msg_type);
         _m_impl->set_length(data.length());
-        auto istream = concurrency::streams::bytestream::open_istream<std::string>(std::move(data));
-        _m_impl->set_body(istream);
+        m_body = concurrency::streams::container_buffer<std::string>(std::move(data));
     }
 
-    void _set_message(concurrency::streams::istream istream, size_t len, websocket_message_type msg_type)
+    void _set_message(const std::string &data, websocket_message_type msg_type)
     {
         _m_impl->set_msg_type(msg_type);
-        _m_impl->set_body(istream);
-        _m_impl->set_length(len);
+        _m_impl->set_length(data.length());
+        m_body = concurrency::streams::container_buffer<std::string>(data);
     }
 
-    pplx::task_completion_event<void> m_send_tce;
+    void _set_message(const concurrency::streams::istream &istream, size_t len, websocket_message_type msg_type)
+    {
+        _m_impl->set_msg_type(msg_type);
+        _m_impl->set_length(len);
+        m_body = istream.streambuf();
+    }
 };
 
 /// <summary>
@@ -216,15 +221,17 @@ class websocket_outgoing_message
 class websocket_incoming_message
 {
 public:
-    websocket_incoming_message(): _m_impl(std::make_shared<details::_websocket_message>()) { }
+    websocket_incoming_message() : _m_impl(std::make_shared<details::_websocket_message>())
+    {
+    }
 
     /// <summary>
     /// Extracts the body of the incoming message as a string value, only if the message type is UTF-8.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
     /// <returns>String containing body of the message.</returns>
     _ASYNCRTIMP pplx::task<std::string> extract_string() const;
-
+    
     /// <summary>
     /// Produces a stream which the caller may use to retrieve body from an incoming message.
     /// Can be used for both UTF-8 (text) and binary message types.
@@ -235,7 +242,11 @@ class websocket_incoming_message
     /// </remarks>
     concurrency::streams::istream body() const
     {
-        return _m_impl->streambuf().create_istream();
+        auto to_uint8_t_stream = [](const concurrency::streams::streambuf<uint8_t> &buf) -> concurrency::streams::istream
+        {
+            return buf.create_istream();
+        };
+        return to_uint8_t_stream(m_body);
     }
 
     /// <summary>
@@ -257,6 +268,14 @@ class websocket_incoming_message
 private:
     friend class details::winrt_client;
     friend class details::ws_desktop_client;
+#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;
+    
     std::shared_ptr<details::_websocket_message> _m_impl;
 };