Merge branch 'listenercloseissue' into staging

Author: stgates

Release/include/cpprest/filestream.h

@@ -111,7 +111,8 @@ namespace details {
         typedef typename basic_streambuf<_CharType>::pos_type pos_type;
         typedef typename basic_streambuf<_CharType>::off_type off_type;
 
-        virtual ~basic_file_buffer() {
+        virtual ~basic_file_buffer() 
+        {
             if( this->can_read() )
             {
                 this->_close_read().wait();
@@ -122,6 +123,7 @@ namespace details {
                 this->_close_write().wait();
             }
         }
+
     protected:
 
         /// <summary>

Release/include/cpprest/http_client_impl.h

@@ -388,7 +388,7 @@ class _http_client_communicator
 
     // Queue used to guarantee ordering of requests, when applicable.
     std::queue<std::shared_ptr<request_context>> m_requests_queue;
-    int                           m_scheduled;
+    int m_scheduled;
 };
 
 inline void request_context::finish()

Release/include/cpprest/http_listener.h

@@ -157,7 +157,7 @@ class http_listener_impl
     /// Handler for all requests. The HTTP host uses this to dispatch a message to the pipeline.
     /// </summary>
     /// <remarks>Only HTTP server implementations should call this API.</remarks>
-    _ASYNCRTIMP pplx::task<http::http_response> handle_request(http::http_request msg);
+    _ASYNCRTIMP void handle_request(http::http_request msg);
 
     const http::uri & uri() const { return m_uri; }
 

Release/include/cpprest/http_msg.h

@@ -344,10 +344,10 @@ class _http_response : public http::details::http_msg_base
 
     _http_server_context * _get_server_context() const { return m_server_context.get(); }
 
-    void _set_server_context(std::shared_ptr<details::_http_server_context> server_context) { m_server_context = std::move(server_context); }
+    void _set_server_context(std::unique_ptr<details::_http_server_context> server_context) { m_server_context = std::move(server_context); }
 
 private:
-    std::shared_ptr<_http_server_context> m_server_context;
+    std::unique_ptr<_http_server_context> m_server_context;
 
     unsigned long m_error_code;
 
@@ -611,7 +611,7 @@ class http_response
     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(); }
-    void _set_server_context(std::shared_ptr<http::details::_http_server_context> server_context) { _m_impl->_set_server_context(std::move(server_context)); }
+    void _set_server_context(std::unique_ptr<http::details::_http_server_context> server_context) { _m_impl->_set_server_context(std::move(server_context)); }
 
 private:
 
@@ -638,9 +638,9 @@ class _http_request : public http::details::http_msg_base, public std::enable_sh
 
     _ASYNCRTIMP _http_request(http::method mtd);
 
-    _ASYNCRTIMP _http_request(std::shared_ptr<http::details::_http_server_context> server_context);
+    _ASYNCRTIMP _http_request(std::unique_ptr<http::details::_http_server_context> server_context);
 
-    virtual ~_http_request() { }
+    virtual ~_http_request() {}
 
     http::method &method() { return m_method; }
 
@@ -686,7 +686,7 @@ class _http_request : public http::details::http_msg_base, public std::enable_sh
 
     http::details::_http_server_context * _get_server_context() const { return m_server_context.get(); }
 
-    void _set_server_context(std::shared_ptr<http::details::_http_server_context> server_context) { m_server_context = std::move(server_context); }
+    void _set_server_context(std::unique_ptr<http::details::_http_server_context> server_context) { m_server_context = std::move(server_context); }
 
     void _set_listener_path(const utility::string_t &path) { m_listener_path = path; }
 
@@ -707,7 +707,7 @@ class _http_request : public http::details::http_msg_base, public std::enable_sh
     http::uri m_base_uri;
     http::uri m_uri;
     utility::string_t m_listener_path;
-    std::shared_ptr<http::details::_http_server_context> m_server_context;
+    std::unique_ptr<http::details::_http_server_context> m_server_context;
 
     concurrency::streams::ostream m_response_stream;
 
@@ -1134,8 +1134,8 @@ class http_request
     /// <summary>
     /// These are used for the initial creation of the HTTP request.
     /// </summary>
-    static http_request _create_request(std::shared_ptr<http::details::_http_server_context> server_context) { return http_request(std::move(server_context)); }
-    void _set_server_context(std::shared_ptr<http::details::_http_server_context> server_context) { _m_impl->_set_server_context(std::move(server_context)); }
+    static http_request _create_request(std::unique_ptr<http::details::_http_server_context> server_context) { return http_request(std::move(server_context)); }
+    void _set_server_context(std::unique_ptr<http::details::_http_server_context> server_context) { _m_impl->_set_server_context(std::move(server_context)); }
 
     void _set_listener_path(const utility::string_t &path) { _m_impl->_set_listener_path(path); }
 
@@ -1160,7 +1160,7 @@ class http_request
     friend class http::details::_http_request;
     friend class http::client::http_client;
 
-    http_request(std::shared_ptr<http::details::_http_server_context> server_context) : _m_impl(std::shared_ptr<details::_http_request>(new details::_http_request(std::move(server_context)))) {}
+    http_request(std::unique_ptr<http::details::_http_server_context> server_context) : _m_impl(std::make_shared<details::_http_request>(std::move(server_context))) {}
     http_request(std::shared_ptr<http::details::_http_request> message) : _m_impl(message) {}
 
     /// <summary>

Release/include/cpprest/http_windows_server.h

@@ -102,7 +102,7 @@ struct windows_request_context : http::details::_http_server_context
     void async_process_request(HTTP_REQUEST_ID request_id, http::http_request msg, const unsigned long headers_size);
 
     // Dispatch request to the provided http_listener.
-    void dispatch_request_to_listener(http_request& request, _In_ web::http::experimental::listener::details::http_listener_impl *pListener);
+    void dispatch_request_to_listener(_In_ web::http::experimental::listener::details::http_listener_impl *pListener);
 
     // Read in a portion of the request body.
     void read_request_body_chunk();
@@ -128,6 +128,8 @@ struct windows_request_context : http::details::_http_server_context
     void cancel_request_io_completion(DWORD error_code, DWORD bytes_read);
 
     // TCE that indicates the completion of response
+    // Workaround for ppl task_completion_event bug.
+    std::mutex m_responseCompletedLock;
     pplx::task_completion_event<void> m_response_completed;
 
     // Id of the currently processed request on this connection.

Release/src/http/common/http_msg.cpp

@@ -534,7 +534,7 @@ details::_http_request::_http_request(http::method mtd)
     }
 }
 
-details::_http_request::_http_request(std::shared_ptr<http::details::_http_server_context> server_context)
+details::_http_request::_http_request(std::unique_ptr<http::details::_http_server_context> server_context)
   : m_initiated_response(0), 
     m_server_context(std::move(server_context)),
     m_cancellationToken(pplx::cancellation_token::none())

Release/src/http/listener/http_listener.cpp

@@ -137,7 +137,7 @@ pplx::task<void> details::http_listener_impl::close()
     return web::http::experimental::details::http_server_api::unregister_listener(this);
 }
 
-pplx::task<http_response> details::http_listener_impl::handle_request(http_request msg)
+void details::http_listener_impl::handle_request(http_request msg)
 {
     // Specific method handler takes priority over general.
     const method &mtd = msg.method();
@@ -165,8 +165,6 @@ pplx::task<http_response> details::http_listener_impl::handle_request(http_reque
         response.headers().add(U("Allow"), get_supported_methods());
         msg.reply(response);
     }
-
-    return msg.get_response();
 }
 
 utility::string_t details::http_listener_impl::get_supported_methods() const 

Release/src/http/listener/http_msg_listen.cpp

@@ -60,10 +60,10 @@ pplx::task<void> details::_http_request::_reply_impl(http_response response)
 #if !defined(__cplusplus_winrt)
     auto server_api = experimental::details::http_server_api::server_api();
 
-    if ( m_server_context && server_api )
+    if (m_server_context && server_api)
     {
         // Add a task-based continuation so no exceptions thrown from the task go 'unobserved'.
-        response._set_server_context(m_server_context);
+        response._set_server_context(std::move(m_server_context));
         response_completed = experimental::details::http_server_api::server_api()->respond(response); 
         response_completed.then([](pplx::task<void> t)
         {