Merge remote-tracking branch 'upstream/development' into cancellation

Conflicts:
	Release/src/http/client/http_linux.cpp

Author: Valtteri Heikkila

Binaries/Debug64/run_tests.sh

@@ -111,7 +111,7 @@ Version 3.0
 // For some reason we keep getting compiler errors on OS X/iOS if nullptr isn't
 // defined to NULL
 #define NEEDS_NULLPTR_DEFINED 1
-#elif __has_feature
+#elif defined(__has_feature)
 #if __has_feature(cxx_nullptr)
 #define NEEDS_NULLPTR_DEFINED 0
 #else

Binaries/Release64/run_tests.sh

@@ -142,16 +142,14 @@ class request_context
     /// </summary>
     void complete_request(size_t body_size)
     {
-        m_response.set_error_code(0);
         m_response._get_impl()->_complete(body_size);
 
         finish();
     }
 
     void report_error(unsigned long error_code, const utility::string_t & errorMessage)
     {
-        m_response.set_error_code(error_code);
-        report_exception(http_exception((int)m_response.error_code(), errorMessage));
+        report_exception(http_exception((int)error_code, errorMessage));
     }
 
     template<typename _ExceptionType>

Release/include/compat/SafeInt3.hpp

@@ -224,8 +224,8 @@ class http_msg_base
     _ASYNCRTIMP void set_body(concurrency::streams::istream instream, utility::string_t contentType);
     _ASYNCRTIMP void set_body(concurrency::streams::istream instream, utility::size64_t contentLength, utility::string_t contentType);
 
-    _ASYNCRTIMP utility::string_t _extract_string();
-    _ASYNCRTIMP json::value _extract_json();
+    _ASYNCRTIMP utility::string_t _extract_string(bool force = false);
+    _ASYNCRTIMP json::value _extract_json(bool force = false);
     _ASYNCRTIMP std::vector<unsigned char> _extract_vector();
 
     virtual _ASYNCRTIMP utility::string_t to_string() const;
@@ -324,18 +324,14 @@ class _http_server_context
 class _http_response : public http::details::http_msg_base
 {
 public:
-    _http_response() : m_status_code((std::numeric_limits<uint16_t>::max)()), m_error_code(0) { }
+    _http_response() : m_status_code((std::numeric_limits<uint16_t>::max)()) { }
 
-    _http_response(http::status_code code) : m_status_code(code), m_error_code(0) {}
+    _http_response(http::status_code code) : m_status_code(code) {}
 
     http::status_code status_code() const { return m_status_code; } 
 
     void set_status_code(http::status_code code) { m_status_code = code; }
 
-    unsigned long error_code() const { return m_error_code; } 
-
-    void set_error_code(unsigned long code) { m_error_code = code; }
-
     const http::reason_phrase & reason_phrase() const { return m_reason_phrase; }
 
     void set_reason_phrase(http::reason_phrase reason) { m_reason_phrase = std::move(reason); }
@@ -349,8 +345,6 @@ class _http_response : public http::details::http_msg_base
 private:
     std::unique_ptr<_http_server_context> m_server_context;
 
-    unsigned long m_error_code;
-
     http::status_code m_status_code;
     http::reason_phrase m_reason_phrase;
 };
@@ -445,22 +439,24 @@ class http_response
     /// Extracts the body of the response message as a string value, checking that the content type is a MIME text type.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>String containing body of the message.</returns>
-    pplx::task<utility::string_t> extract_string() const
+    pplx::task<utility::string_t> extract_string(bool force = false) const
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_string(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_string(force); });
     }
 
     /// <summary>
     /// Extracts the body of the response message into a json value, checking that the content type is application\json.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>JSON value from the body of this message.</returns>
-    pplx::task<json::value> extract_json() const
+    pplx::task<json::value> extract_json(bool force = false) const
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_json(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_json(force); });
     }
 
     /// <summary>
@@ -596,18 +592,6 @@ class http_response
         return pplx::create_task(impl->_get_data_available()).then([impl](utility::size64_t) -> http_response { return http_response(impl); });
     }
 
-    /// <summary>
-    /// Gets the error code of the response. This is used for errors other than HTTP status codes.
-    /// </summary>
-    /// <returns>The error code.</returns>
-    unsigned long error_code() const { return _m_impl->error_code(); }
-
-    /// <summary>
-    /// Sets the error code of the response. This is used for errors other than HTTP status codes.
-    /// </summary>
-    /// <param name="code">The error code</param>
-    void set_error_code(unsigned long code) const { _m_impl->set_error_code(code); }
-
     std::shared_ptr<http::details::_http_response> _get_impl() const { return _m_impl; }
 
     http::details::_http_server_context * _get_server_context() const { return _m_impl->_get_server_context(); }
@@ -620,7 +604,6 @@ class http_response
     {
     }
 
-private:
     std::shared_ptr<http::details::_http_response> _m_impl;
 };
 
@@ -826,22 +809,24 @@ class http_request
     /// Extract the body of the request message as a string value, checking that the content type is a MIME text type.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>String containing body of the message.</returns>
-    pplx::task<utility::string_t> extract_string()
+    pplx::task<utility::string_t> extract_string(bool force = false)
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_string(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_string(force); });
     }
 
     /// <summary>
     /// Extracts the body of the request message into a json value, checking that the content type is application\json.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>JSON value from the body of this message.</returns>
-    pplx::task<json::value> extract_json() const
+    pplx::task<json::value> extract_json(bool force = false) const
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_json(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_json(force); });
     }
 
     /// <summary>

Release/include/cpprest/http_client_impl.h

@@ -70,9 +70,7 @@ namespace details
 /// </summary>
 enum class websocket_message_type
 {
-    text_fragment,
     text_message,
-    binary_fragment,
     binary_message,
     close,
     ping,
@@ -137,15 +135,6 @@ class websocket_outgoing_message
     websocket_outgoing_message()
         : _m_impl(std::make_shared<details::_websocket_message>()) {}
 
-    /// <summary>
-    /// Sets a UTF-8 fragment as the message body.
-    /// </summary>
-    /// <params>UTF-8 String containing body of the fragment.</returns>
-    void set_utf8_fragment(std::string data)
-    {
-        this->_set_message(std::move(data), websocket_message_type::text_fragment);
-    }
-
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
@@ -155,31 +144,14 @@ class websocket_outgoing_message
         this->_set_message(std::move(data), websocket_message_type::text_message);
     }
 
-    /// <summary>
-    /// Sets a UTF-8 fragment as the message body.
-    /// </summary>
-    /// <params>casablanca input stream representing the body of the fragment.</returns>
-    void set_utf8_fragment(concurrency::streams::istream istream, size_t len)
-    {
-        this->_set_message(istream, len, websocket_message_type::text_fragment);
-    }
-
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
-    /// <params>casablanca input stream representing the body of the fragment.</returns>
+    /// <params>casablanca input stream representing the body of the message.</returns>
     void set_utf8_message(concurrency::streams::istream istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::text_message);
     }
-    /// <summary>
-    /// Sets a binary fragment as the message body.
-    /// </summary>
-    /// <params>casablanca input stream representing the body of the fragment.</returns>
-    void set_binary_fragment(concurrency::streams::istream istream, size_t len)
-    {
-        this->_set_message(istream, len, websocket_message_type::binary_fragment);
-    }
 
     /// <summary>
     /// Sets binary data as the message body.

Release/include/cpprest/http_msg.h

@@ -149,9 +149,7 @@ void BlackjackClient::PlayingTable::Refresh()
 
 void BlackjackClient::PlayingTable::InterpretResponse(http_response &response)
 {
-    HRESULT responseHR = response.error_code();
-
-    if ( InterpretError(responseHR) || response.headers().content_type() != L"application/json" ) return;
+    if ( response.headers().content_type() != L"application/json" ) return;
 
     this->resultLabel->Text = L"";
 

Release/include/cpprest/ws_msg.h

@@ -30,7 +30,6 @@
 #include "stdafx.h"
 
 #include "cpprest/http_client_impl.h"
-#include <limits>
 #include <unordered_set>
 
 using boost::asio::ip::tcp;
@@ -56,6 +55,7 @@ namespace web { namespace http
             class linux_connection_pool;
             class linux_connection : public std::enable_shared_from_this<linux_connection>
             {
+                friend class linux_connection_pool;
             public:
                 linux_connection(std::weak_ptr<linux_connection_pool> pool_weak, boost::asio::io_service& io_service) :
                     m_socket(io_service),
@@ -65,8 +65,6 @@ namespace web { namespace http
                     m_keep_alive(true)
                 {}
 
-                void handle_pool_timer(const boost::system::error_code& ec);
-
                 bool close(bool cancel_timer)
                 {
                     if (cancel_timer)
@@ -87,6 +85,14 @@ namespace web { namespace http
                     return !error;
                 }
 
+                bool is_reused() const { return m_is_reused; }
+
+                void set_keep_alive(bool keep_alive) { m_keep_alive = keep_alive; }
+                bool keep_alive() const { return m_keep_alive; }
+
+                tcp::socket& socket() { return m_socket; }
+
+            private:
                 template <typename TimeoutHandler>
                 void start_pool_timer(int timeout_secs, TimeoutHandler handler)
                 {
@@ -100,14 +106,8 @@ namespace web { namespace http
                     m_is_reused = true;
                 }
 
-                bool is_reused() const { return m_is_reused; }
-
-                bool keep_alive() const { return m_keep_alive; }
-                void set_keep_alive(bool keep_alive) { m_keep_alive = keep_alive; }
-
-                tcp::socket& socket() { return m_socket; }
+                void handle_pool_timer(const boost::system::error_code& ec);
 
-            private:
                 tcp::socket m_socket;
                 boost::asio::deadline_timer m_pool_timer;
                 std::weak_ptr<linux_connection_pool> m_pool_weak;

Release/samples/BlackJack/BlackJack_UIClient/PlayingTable.xaml.cpp

@@ -196,21 +196,24 @@ void http_msg_base::_complete(utility::size64_t body_size, std::exception_ptr ex
     }
 }
 
-utility::string_t details::http_msg_base::_extract_string()
+utility::string_t details::http_msg_base::_extract_string(bool force)
 {
-    utility::string_t content, charset;
-    parse_content_type_and_charset(headers().content_type(), content, charset);
-
-    // If no Content-Type then just return an empty string.
-    if(content.empty())
+    utility::string_t content, charset = charset_types::utf8;
+    if (!force)
     {
-        return utility::string_t();
-    }
+        parse_content_type_and_charset(headers().content_type(), content, charset);
 
-    // Content-Type must have textual type.
-    if(!is_content_type_textual(content))
-    {
-        throw http_exception(textual_content_type_missing);
+        // If no Content-Type then just return an empty string.
+        if (content.empty())
+        {
+            return utility::string_t();
+        }
+
+        // Content-Type must have textual type.
+        if (!is_content_type_textual(content))
+        {
+            throw http_exception(textual_content_type_missing);
+        }
     }
 
     if (!instream())
@@ -287,22 +290,25 @@ utility::string_t details::http_msg_base::_extract_string()
     }
 }
 
-json::value details::http_msg_base::_extract_json()
+json::value details::http_msg_base::_extract_json(bool force)
 {
-    utility::string_t content, charset;
-    parse_content_type_and_charset(headers().content_type(), content, charset);
-
-    // If no Content-Type then just return a null json value.
-    if(content.empty())
+    utility::string_t content, charset = charset_types::utf8;
+    if (!force)
     {
-        return json::value();
-    }
+        parse_content_type_and_charset(headers().content_type(), content, charset);
 
-    // Content-Type must be "application/json" or one of the unofficial, but common JSON types.
-    if(!is_content_type_json(content))
-    {
-        const utility::string_t actualContentType = utility::conversions::to_string_t(content);
-        throw http_exception((_XPLATSTR("Content-Type must be JSON to extract (is: ") + actualContentType + _XPLATSTR(")")));
+        // If no Content-Type then just return a null json value.
+        if (content.empty())
+        {
+            return json::value();
+        }
+
+        // Content-Type must be "application/json" or one of the unofficial, but common JSON types.
+        if (!is_content_type_json(content))
+        {
+            const utility::string_t actualContentType = utility::conversions::to_string_t(content);
+            throw http_exception((_XPLATSTR("Content-Type must be JSON to extract (is: ") + actualContentType + _XPLATSTR(")")));
+        }
     }
 
     if (!instream())

Release/src/http/client/http_linux.cpp

@@ -83,8 +83,7 @@ std::string details::_websocket_message::_extract_string()
 
 pplx::task<std::string> websocket_incoming_message::extract_string() const
 {
-    if (_m_impl->message_type() == websocket_message_type::binary_fragment ||
-        _m_impl->message_type() == websocket_message_type::binary_message)
+    if (_m_impl->message_type() == websocket_message_type::binary_message)
     {
         return pplx::task_from_exception<std::string>(websocket_exception(_XPLATSTR("Invalid message type")));
     }