Deprecating misspelled API websocket_incoming_message::messge_type(), replaced with websocket_incoming_message::message_type().e Please enter the commit message for your changes. Lines starting

stgates · stgates · commit b3a30cee2693 · 2014-11-06T09:51:57.000-08:00
diff --git a/Release/include/cpprest/ws_msg.h b/Release/include/cpprest/ws_msg.h
@@ -256,11 +256,21 @@ class websocket_incoming_message
     /// <summary>
     /// Returns the type of the received message.
     /// </summary>
+    CASABLANCA_DEPRECATED("Incorrectly spelled API, use message_type() instead.")
     websocket_message_type messge_type() const
     {
         return _m_impl->message_type();
     }
 
+    /// <summary>
+    /// Returns the type of the received message, either string or binary.
+    /// </summary>
+    /// <returns>websocket_message_type</returns>
+    websocket_message_type message_type() const
+    {
+        return _m_impl->message_type();
+    }
+
 private:
     friend class details::winrt_client;
     friend class details::wspp_client;
diff --git a/Release/src/websockets/client/ws_winrt.cpp b/Release/src/websockets/client/ws_winrt.cpp
@@ -233,18 +233,16 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
             return pplx::task_from_exception<void>(websocket_exception("Message size too large. Ensure message length is less than UINT_MAX."));
         }
 
+        if (++m_num_sends == 1) // No sends in progress
         {
-            if (++m_num_sends == 1) // No sends in progress
-            {
-                // Start sending the message
-                send_msg(msg);
-            }
-            else
-            {
-                // Only actually have to take the lock if touching the queue.
-                std::lock_guard<std::mutex> lock(m_send_lock);
-                m_outgoing_msg_queue.push(msg);
-            }
+            // Start sending the message
+            send_msg(msg);
+        }
+        else
+        {
+            // Only actually have to take the lock if touching the queue.
+            std::lock_guard<std::mutex> lock(m_send_lock);
+            m_outgoing_msg_queue.push(msg);
         }
         return pplx::create_task(msg.body_sent());
     }
@@ -347,13 +345,9 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
                     eptr = std::make_exception_ptr(websocket_exception("Failed to send all the bytes."));
                 }
             }
-            catch (const websocket_exception& ex)
-            {
-                eptr = std::make_exception_ptr(ex);
-            }
             catch (...)
             {
-                eptr = std::make_exception_ptr(websocket_exception("Failed to send data over the websocket connection."));
+                eptr = std::make_exception_ptr(std::current_exception());
             }
 
             if (acquired)
@@ -366,21 +360,22 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr
             {
                 msg.signal_body_sent(eptr);
             }
+            else
+            {
+                msg.signal_body_sent();
+            }
 
+            if (--this_client->m_num_sends > 0)
             {
-                if (--this_client->m_num_sends > 0)
+                // Only hold the lock when actually touching the queue.
+                websocket_outgoing_message next_msg;
                 {
-                    // Only hold the lock when actually touching the queue.
-                    websocket_outgoing_message next_msg;
-                    {
-                        std::lock_guard<std::mutex> lock(this_client->m_send_lock);
-                        next_msg = this_client->m_outgoing_msg_queue.front();
-                        this_client->m_outgoing_msg_queue.pop();
-                    }
-                    this_client->send_msg(next_msg);
+                    std::lock_guard<std::mutex> lock(this_client->m_send_lock);
+                    next_msg = this_client->m_outgoing_msg_queue.front();
+                    this_client->m_outgoing_msg_queue.pop();
                 }
+                this_client->send_msg(next_msg);
             }
-            msg.signal_body_sent();
         });
     }
 
@@ -490,7 +485,7 @@ void ReceiveContext::OnReceive(MessageWebSocket^ sender, MessageWebSocketMessage
         msg->set_length(len);
         m_receive_handler(ws_incoming_message);
     }
-    catch(...)
+    catch (...)
     {
         // Swallow the exception for now. Following up on this with the WinRT team.
         // We can handle this more gracefully once we know the scenarios where DataReader operations can throw an exception:
diff --git a/Release/tests/functional/websockets/client/authentication_tests.cpp b/Release/tests/functional/websockets/client/authentication_tests.cpp
@@ -98,7 +98,7 @@ TEST(ssl_test)
 
         VERIFY_ARE_EQUAL(ret_msg.length(), body_str.length());
         VERIFY_ARE_EQUAL(body_str.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
 
     websocket_outgoing_message msg;
diff --git a/Release/tests/functional/websockets/client/client_construction.cpp b/Release/tests/functional/websockets/client/client_construction.cpp
@@ -128,7 +128,7 @@ TEST_FIXTURE(uri_address, move_operations)
 
         VERIFY_ARE_EQUAL(ret_msg.length(), body.length());
         VERIFY_ARE_EQUAL(body.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
 
     test_websocket_msg rmsg;
@@ -158,7 +158,7 @@ TEST_FIXTURE(uri_address, move_operations)
 
         VERIFY_ARE_EQUAL(ret_msg.length(), body.length());
         VERIFY_ARE_EQUAL(body.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
     t1.wait();
     client.close().wait();
diff --git a/Release/tests/functional/websockets/client/receive_msg_tests.cpp b/Release/tests/functional/websockets/client/receive_msg_tests.cpp
@@ -57,7 +57,7 @@ pplx::task<void> receive_text_msg_helper(websocket_client& client,
 
         VERIFY_ARE_EQUAL(ret_msg.length(), body_str.length());
         VERIFY_ARE_EQUAL(body_str.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
 
     test_websocket_msg msg;
@@ -87,9 +87,9 @@ pplx::task<void> receive_msg_stream_helper(websocket_client& client,
         VERIFY_ARE_EQUAL(ret_msg.length(), body.size());
         VERIFY_ARE_EQUAL(body, ret_data.collection());
         if (type == test_websocket_message_type::WEB_SOCKET_BINARY_MESSAGE_TYPE)
-            VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::binary_message);
+            VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::binary_message);
         else if (type == test_websocket_message_type::WEB_SOCKET_UTF8_MESSAGE_TYPE)
-            VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+            VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
     
     test_websocket_msg msg;
@@ -154,7 +154,7 @@ TEST_FIXTURE(uri_address, receive_text_msg_fragments, "Ignore", "898451")
         auto ret_str = ret_msg.extract_string().get();
 
         VERIFY_ARE_EQUAL(body_str.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
 
     test_websocket_msg msg1;
@@ -235,7 +235,7 @@ TEST_FIXTURE(uri_address, receive_after_server_send)
     {
         auto ret_str = ret_msg.extract_string().get();
         VERIFY_ARE_EQUAL(body_str.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     }).wait();
 
     client.close().wait();
@@ -256,7 +256,7 @@ TEST_FIXTURE(uri_address, receive_before_connect)
 
         VERIFY_ARE_EQUAL(ret_msg.length(), body_str.length());
         VERIFY_ARE_EQUAL(body_str.compare(ret_str), 0);
-        VERIFY_ARE_EQUAL(ret_msg.messge_type(), websocket_message_type::text_message);
+        VERIFY_ARE_EQUAL(ret_msg.message_type(), websocket_message_type::text_message);
     });
     
     // Connect after the client is waiting on a receive task.

Original file line number	Diff line number	Diff line change
`@@ -233,18 +233,16 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr`
`233`	`233`	`return pplx::task_from_exception<void>(websocket_exception("Message size too large. Ensure message length is less than UINT_MAX."));`
`234`	`234`	`}`
`235`	`235`
	`236`	`+ if (++m_num_sends == 1) // No sends in progress`
`236`	`237`	`{`
`237`		`- if (++m_num_sends == 1) // No sends in progress`
`238`		`- {`
`239`		`- // Start sending the message`
`240`		`- send_msg(msg);`
`241`		`- }`
`242`		`- else`
`243`		`- {`
`244`		`- // Only actually have to take the lock if touching the queue.`
`245`		`- std::lock_guard<std::mutex> lock(m_send_lock);`
`246`		`- m_outgoing_msg_queue.push(msg);`
`247`		`- }`
	`238`	`+ // Start sending the message`
	`239`	`+ send_msg(msg);`
	`240`	`+ }`
	`241`	`+ else`
	`242`	`+ {`
	`243`	`+ // Only actually have to take the lock if touching the queue.`
	`244`	`+ std::lock_guard<std::mutex> lock(m_send_lock);`
	`245`	`+ m_outgoing_msg_queue.push(msg);`
`248`	`246`	`}`
`249`	`247`	`return pplx::create_task(msg.body_sent());`
`250`	`248`	`}`
`@@ -347,13 +345,9 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr`
`347`	`345`	`eptr = std::make_exception_ptr(websocket_exception("Failed to send all the bytes."));`
`348`	`346`	`}`
`349`	`347`	`}`
`350`		`- catch (const websocket_exception& ex)`
`351`		`- {`
`352`		`- eptr = std::make_exception_ptr(ex);`
`353`		`- }`
`354`	`348`	`catch (...)`
`355`	`349`	`{`
`356`		`- eptr = std::make_exception_ptr(websocket_exception("Failed to send data over the websocket connection."));`
	`350`	`+ eptr = std::make_exception_ptr(std::current_exception());`
`357`	`351`	`}`
`358`	`352`
`359`	`353`	`if (acquired)`
`@@ -366,21 +360,22 @@ class winrt_client : public _websocket_client_impl, public std::enable_shared_fr`
`366`	`360`	`{`
`367`	`361`	`msg.signal_body_sent(eptr);`
`368`	`362`	`}`
	`363`	`+ else`
	`364`	`+ {`
	`365`	`+ msg.signal_body_sent();`
	`366`	`+ }`
`369`	`367`
	`368`	`+ if (--this_client->m_num_sends > 0)`
`370`	`369`	`{`
`371`		`- if (--this_client->m_num_sends > 0)`
	`370`	`+ // Only hold the lock when actually touching the queue.`
	`371`	`+ websocket_outgoing_message next_msg;`
`372`	`372`	`{`
`373`		`- // Only hold the lock when actually touching the queue.`
`374`		`- websocket_outgoing_message next_msg;`
`375`		`- {`
`376`		`- std::lock_guard<std::mutex> lock(this_client->m_send_lock);`
`377`		`- next_msg = this_client->m_outgoing_msg_queue.front();`
`378`		`- this_client->m_outgoing_msg_queue.pop();`
`379`		`- }`
`380`		`- this_client->send_msg(next_msg);`
	`373`	`+ std::lock_guard<std::mutex> lock(this_client->m_send_lock);`
	`374`	`+ next_msg = this_client->m_outgoing_msg_queue.front();`
	`375`	`+ this_client->m_outgoing_msg_queue.pop();`
`381`	`376`	`}`
	`377`	`+ this_client->send_msg(next_msg);`
`382`	`378`	`}`
`383`		`- msg.signal_body_sent();`
`384`	`379`	`});`
`385`	`380`	`}`
`386`	`381`
`@@ -490,7 +485,7 @@ void ReceiveContext::OnReceive(MessageWebSocket^ sender, MessageWebSocketMessage`
`490`	`485`	`msg->set_length(len);`
`491`	`486`	`m_receive_handler(ws_incoming_message);`
`492`	`487`	`}`
`493`		`- catch(...)`
	`488`	`+ catch (...)`
`494`	`489`	`{`
`495`	`490`	`// Swallow the exception for now. Following up on this with the WinRT team.`
`496`	`491`	`// We can handle this more gracefully once we know the scenarios where DataReader operations can throw an exception:`