Merge branch 'development' of https://git01.codeplex.com/casablanca into ws_winrt_connection

Author: stgates

Release/include/cpprest/containerstream.h

@@ -120,7 +120,7 @@ namespace Concurrency { namespace streams {
         /// </summary>
         virtual utility::size64_t size() const
         {
-            return utility::size64_t(m_size);
+            return utility::size64_t(m_data.size());
         }
 
         /// <summary>
@@ -153,10 +153,10 @@ namespace Concurrency { namespace streams {
         {
             // See the comment in seek around the restriction that we do not allow read head to
             // seek beyond the current write_end.
-            _ASSERTE(m_current_position <= m_size);
+            _ASSERTE(m_current_position <= m_data.size());
 
             SafeSize readhead(m_current_position);
-            SafeSize writeend(m_size);
+            SafeSize writeend(m_data.size());
             return (size_t)(writeend - readhead);
         }
 
@@ -330,7 +330,7 @@ namespace Concurrency { namespace streams {
             // For now, we assume that the current write_end is the end of the buffer. We use this artificial
             // end to restrict the read head from seeking beyond what is available.
 
-            pos_type end(m_size);
+            pos_type end(m_data.size());
 
             if (position >= beg)
             {
@@ -378,7 +378,7 @@ namespace Concurrency { namespace streams {
         {
             pos_type beg = 0;
             pos_type cur = static_cast<pos_type>(m_current_position);
-            pos_type end = static_cast<pos_type>(m_size);
+            pos_type end = static_cast<pos_type>(m_data.size());
 
             switch ( way )
             {
@@ -404,8 +404,7 @@ namespace Concurrency { namespace streams {
         /// </summary>
         basic_container_buffer(std::ios_base::openmode mode)
             : streambuf_state_manager<typename _CollectionType::value_type>(mode),
-              m_current_position(0),
-              m_size(0)
+              m_current_position(0)
         {
             validate_mode(mode);
         }
@@ -416,8 +415,7 @@ namespace Concurrency { namespace streams {
         basic_container_buffer(_CollectionType data, std::ios_base::openmode mode)
             : streambuf_state_manager<typename _CollectionType::value_type>(mode),
               m_data(std::move(data)),
-              m_current_position((mode & std::ios_base::in) ? 0 : m_data.size()),
-              m_size(m_data.size())
+              m_current_position((mode & std::ios_base::in) ? 0 : m_data.size())
         {
             validate_mode(mode);
         }
@@ -509,10 +507,8 @@ namespace Concurrency { namespace streams {
         /// </summary>
         void resize_for_write(size_t newPos)
         {
-            _ASSERTE(m_size <= m_data.size());
-
             // Resize the container if required
-            if (newPos > m_size)
+            if (newPos > m_data.size())
             {
                 m_data.resize(newPos);
             }
@@ -525,23 +521,14 @@ namespace Concurrency { namespace streams {
         {
             // The new write head
             m_current_position = newPos;
-
-            if ( this->can_write() && m_size < m_current_position)
-            {
-                // Update the size of the buffer with valid data if required
-                m_size = m_current_position;
-            }
-
-            _ASSERTE(m_current_position <= m_size);
-            _ASSERTE(m_size <= m_data.size());
+            _ASSERTE(m_current_position <= m_data.size());
         }
 
         // The actual data store
         _CollectionType m_data;
 
         // Read/write head
         size_t m_current_position;
-        size_t m_size;
     };
 
     } // namespace details

Release/include/cpprest/ws_msg.h

@@ -77,46 +77,20 @@ enum class websocket_message_type
     pong
 };
 
-namespace details
-{
-class _websocket_message
-{
-public:
-
-    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() const { return m_length; }
-
-    websocket_message_type message_type() const { return m_msg_type; }
-
-private:
-
-    websocket_message_type m_msg_type;
-    size_t m_length;
-};
-}
-
 /// <summary>
 /// Represents an outgoing websocket message
 /// </summary>
 class websocket_outgoing_message
 {
 public:
 
-    /// <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)
     {
-        this->_set_message(std::move(data), websocket_message_type::text_message);
+        this->set_message(concurrency::streams::container_buffer<std::string>(std::move(data)));
     }
 
     /// <summary>
@@ -125,7 +99,7 @@ class websocket_outgoing_message
     /// <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);
+        this->set_message(concurrency::streams::container_buffer<std::string>(data));
     }
 
     /// <summary>
@@ -135,7 +109,7 @@ class websocket_outgoing_message
     /// <remarks>Upon sending, the entire stream may be buffered to determine the length.</remarks>
     void set_utf8_message(const concurrency::streams::istream &istream)
     {
-        this->_set_message(istream, SIZE_MAX, websocket_message_type::text_message);
+        this->set_message(istream, SIZE_MAX, websocket_message_type::text_message);
     }
 
     /// <summary>
@@ -145,7 +119,7 @@ class websocket_outgoing_message
     /// <param name="len">number of bytes to send.</param>
     void set_utf8_message(const concurrency::streams::istream &istream, size_t len)
     {
-        this->_set_message(istream, len, websocket_message_type::text_message);
+        this->set_message(istream, len, websocket_message_type::text_message);
     }
 
     /// <summary>
@@ -155,7 +129,7 @@ class websocket_outgoing_message
     /// <param name="len">number of bytes to send.</param>
     void set_binary_message(const concurrency::streams::istream &istream, size_t len)
     {
-        this->_set_message(istream, len, websocket_message_type::binary_message);
+        this->set_message(istream, len, websocket_message_type::binary_message);
     }
 
     /// <summary>
@@ -165,17 +139,17 @@ class websocket_outgoing_message
     /// <remarks>Upon sending, the entire stream may be buffered to determine the length.</remarks>
     void set_binary_message(const concurrency::streams::istream &istream)
     {
-        this->_set_message(istream, SIZE_MAX, websocket_message_type::binary_message);
+        this->set_message(istream, SIZE_MAX, websocket_message_type::binary_message);
     }
 
 private:
     friend class details::winrt_client;
     friend class details::wspp_client;
 
-    std::shared_ptr<details::_websocket_message> _m_impl;
-
     pplx::task_completion_event<void> m_body_sent;
     concurrency::streams::streambuf<uint8_t> m_body;
+    websocket_message_type m_msg_type;
+    size_t m_length;
 
     void signal_body_sent() const
     {
@@ -189,24 +163,17 @@ class websocket_outgoing_message
 
     const pplx::task_completion_event<void> & body_sent() const { return m_body_sent; }
 
-    void _set_message(std::string &&data, websocket_message_type msg_type)
+    void set_message(const concurrency::streams::container_buffer<std::string> &buffer)
     {
-        _m_impl->set_msg_type(msg_type);
-        _m_impl->set_length(data.length());
-        m_body = concurrency::streams::container_buffer<std::string>(std::move(data));
+        m_msg_type = websocket_message_type::text_message;
+        m_length = static_cast<size_t>(buffer.size());
+        m_body = buffer;
     }
 
-    void _set_message(const std::string &data, websocket_message_type msg_type)
+    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(data.length());
-        m_body = concurrency::streams::container_buffer<std::string>(data);
-    }
-
-    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_msg_type = msg_type;
+        m_length = len;
         m_body = istream.streambuf();
     }
 };
@@ -217,9 +184,6 @@ class websocket_outgoing_message
 class websocket_incoming_message
 {
 public:
-    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.
@@ -250,7 +214,7 @@ class websocket_incoming_message
     /// </summary>
     size_t length() const
     {
-        return _m_impl->length();
+        return static_cast<size_t>(m_body.size());
     }
 
     /// <summary>
@@ -259,7 +223,7 @@ class websocket_incoming_message
     CASABLANCA_DEPRECATED("Incorrectly spelled API, use message_type() instead.")
     websocket_message_type messge_type() const
     {
-        return _m_impl->message_type();
+        return m_msg_type;
     }
 
     /// <summary>
@@ -268,7 +232,7 @@ class websocket_incoming_message
     /// <returns>websocket_message_type</returns>
     websocket_message_type message_type() const
     {
-        return _m_impl->message_type();
+        return m_msg_type;
     }
 
 private:
@@ -281,8 +245,7 @@ class websocket_incoming_message
     // 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;
+    websocket_message_type m_msg_type;
 };
 
 }}}