HTTP message sending improvements.

1. Combined typedefs duplicated in compat files into basic_types.h.

2. Update documentation for http_request default constructor and made default to
HTTP GET method to avoid ambiguity. Fixes CodePlex #273.

3. For sending HTTP request/response message bodies, which are potentially large amounts of user data
I replaced our value with move functions with two overloads, one taking const reference and the
other r-value reference and moving.

4. For sending HTTP request/response message bodies, I added overload to work with utf8 strings on Windows.
We've received the customer complaints about cross platform strings many times. For a performance critical
portion now customers and use UTF-8 for message bodies on all platforms efficiently. On non Windows
platforms this saves unnecessary copy and moves in some cases. On Windows this saves a copy and string
conversion.

Author: stgates

Release/include/compat/apple_compat.h

@@ -24,7 +24,6 @@
 #pragma once
 
 #include <cstdint>
-#include <string>
 #include <sstream>
 #include <iostream>
 #define __cdecl
@@ -53,13 +52,3 @@
 #else
 #define CASABLANCA_DEPRECATED(x) __attribute__((deprecated(x)))
 #endif
-
-#include <string>
-
-typedef char16_t utf16char;
-typedef std::u16string utf16string;
-typedef std::basic_stringstream<char16_t> utf16stringstream;
-typedef std::basic_ostringstream<char16_t> utf16ostringstream;
-typedef std::basic_ostream<char16_t> utf16ostream;
-typedef std::basic_istream<char16_t> utf16istream;
-typedef std::basic_istringstream<char16_t> utf16istringstream;

Release/include/compat/linux_compat.h

@@ -22,7 +22,6 @@
 
 #pragma once
 #include <cstdint>
-#include <string>
 #include <sstream>
 #include <iostream>
 #define __cdecl __attribute__ ((cdecl))
@@ -55,13 +54,3 @@
 #define CASABLANCA_DEPRECATED(x) __attribute__((deprecated(x)))
 #endif
 
-#include <string>
-
-typedef char16_t utf16char;
-typedef std::u16string utf16string;
-typedef std::basic_stringstream<char16_t> utf16stringstream;
-typedef std::basic_ostringstream<char16_t> utf16ostringstream;
-typedef std::basic_ostream<char16_t> utf16ostream;
-typedef std::basic_istream<char16_t> utf16istream;
-typedef std::basic_istringstream<char16_t> utf16istringstream;
-

Release/include/compat/windows_compat.h

@@ -26,8 +26,6 @@
 ****/
 #pragma once
 
-#include <string>
-
 #if _MSC_VER >= 1700
 // Support VS2012 SAL syntax only
 #include <sal.h>
@@ -43,12 +41,4 @@
 #define CASABLANCA_DEPRECATED(x)
 #else
 #define CASABLANCA_DEPRECATED(x) __declspec(deprecated(x))
-#endif
-
-typedef wchar_t utf16char;
-typedef std::wstring utf16string;
-typedef std::wstringstream utf16stringstream;
-typedef std::wostringstream utf16ostringstream;
-typedef std::wostream utf16ostream;
-typedef std::wistream utf16istream;
-typedef std::wistringstream utf16istringstream;
+#endif

Release/include/cpprest/basic_types.h

@@ -99,3 +99,29 @@ typedef std::stringstream stringstream_t;
 #endif // !_TURN_OFF_PLATFORM_STRING
 
 }// namespace utility
+
+using utf8char = char;
+using utf8string = std::string;
+using utf8stringstream = std::stringstream;
+using utf8ostringstream = std::ostringstream;
+using utf8ostream = std::ostream;
+using utf8istream = std::istream;
+using utf8istringstream = std::istringstream;
+
+#ifdef _UTF16_STRINGS
+typedef wchar_t utf16char;
+typedef std::wstring utf16string;
+typedef std::wstringstream utf16stringstream;
+typedef std::wostringstream utf16ostringstream;
+typedef std::wostream utf16ostream;
+typedef std::wistream utf16istream;
+typedef std::wistringstream utf16istringstream;
+#else
+typedef char16_t utf16char;
+typedef std::u16string utf16string;
+typedef std::basic_stringstream<utf16char> utf16stringstream;
+typedef std::basic_ostringstream<utf16char> utf16ostringstream;
+typedef std::basic_ostream<utf16char> utf16ostream;
+typedef std::basic_istream<utf16char> utf16istream;
+typedef std::basic_istringstream<utf16char> utf16istringstream;
+#endif

Release/include/cpprest/http_client.h

@@ -461,19 +461,65 @@ class http_client
     }
 
     /// <summary>
-    /// Asynchronously sends an HTTP request.
+    /// Asynchronously sends an HTTP request with a string body. Assumes the
+    /// character encoding of the string is UTF-8.
+    /// </summary>
+    /// <param name="mtd">HTTP request method.</param>
+    /// <param name="path_query_fragment">String containing the path, query, and fragment, relative to the http_client's base URI.</param>
+    /// <param name="content_type">A string holding the MIME type of the message body.</param>
+    /// <param name="body_data">String containing the text to use in the message body.</param>
+    /// <param name="token">Cancellation token for cancellation of this request operation.</param>
+    /// <returns>An asynchronous operation that is completed once a response from the request is received.</returns>
+    pplx::task<http_response> request(
+        const method &mtd,
+        const utf8string &path_query_fragment,
+        const utf8string &body_data,
+        const utf8string &content_type = "text/plain; charset=utf-8",
+        const pplx::cancellation_token &token = pplx::cancellation_token::none())
+    {
+        http_request msg(mtd);
+        msg.set_request_uri(::utility::conversions::to_string_t(path_query_fragment));
+        msg.set_body(body_data, content_type);
+        return request(msg, token);
+    }
+
+    /// <summary>
+    /// Asynchronously sends an HTTP request with a string body. Assumes the
+    /// character encoding of the string is UTF-8.
+    /// </summary>
+    /// <param name="mtd">HTTP request method.</param>
+    /// <param name="path_query_fragment">String containing the path, query, and fragment, relative to the http_client's base URI.</param>
+    /// <param name="content_type">A string holding the MIME type of the message body.</param>
+    /// <param name="body_data">String containing the text to use in the message body.</param>
+    /// <param name="token">Cancellation token for cancellation of this request operation.</param>
+    /// <returns>An asynchronous operation that is completed once a response from the request is received.</returns>
+    pplx::task<http_response> request(
+        const method &mtd,
+        const utf8string &path_query_fragment,
+        utf8string &&body_data,
+        const utf8string &content_type = "text/plain; charset=utf-8",
+        const pplx::cancellation_token &token = pplx::cancellation_token::none())
+    {
+        http_request msg(mtd);
+        msg.set_request_uri(::utility::conversions::to_string_t(path_query_fragment));
+        msg.set_body(std::move(body_data), content_type);
+        return request(msg, token);
+    }
+
+    /// <summary>
+    /// Asynchronously sends an HTTP request with a string body. Assumes the
+    /// character encoding of the string is UTF-16 will perform conversion to UTF-8.
     /// </summary>
     /// <param name="mtd">HTTP request method.</param>
     /// <param name="path_query_fragment">String containing the path, query, and fragment, relative to the http_client's base URI.</param>
     /// <param name="content_type">A string holding the MIME type of the message body.</param>
     /// <param name="body_data">String containing the text to use in the message body.</param>
     /// <param name="token">Cancellation token for cancellation of this request operation.</param>
     /// <returns>An asynchronous operation that is completed once a response from the request is received.</returns>
-    // TODO overload???Not sure...
     pplx::task<http_response> request(
         const method &mtd,
         const utility::string_t &path_query_fragment,
-        const utility::string_t &body_data,
+        const utf16string &body_data,
         const utility::string_t &content_type = _XPLATSTR("text/plain"),
         const pplx::cancellation_token &token = pplx::cancellation_token::none())
     {
@@ -484,18 +530,57 @@ class http_client
     }
 
     /// <summary>
-    /// Asynchronously sends an HTTP request.
+    /// Asynchronously sends an HTTP request with a string body. Assumes the
+    /// character encoding of the string is UTF-8.
     /// </summary>
     /// <param name="mtd">HTTP request method.</param>
     /// <param name="path_query_fragment">String containing the path, query, and fragment, relative to the http_client's base URI.</param>
     /// <param name="body_data">String containing the text to use in the message body.</param>
     /// <param name="token">Cancellation token for cancellation of this request operation.</param>
     /// <returns>An asynchronous operation that is completed once a response from the request is received.</returns>
-    // TODO overload not usre???
     pplx::task<http_response> request(
         const method &mtd,
-        const utility::string_t &path_query_fragment,
-        const utility::string_t &body_data,
+        const utf8string &path_query_fragment,
+        const utf8string &body_data,
+        const pplx::cancellation_token &token)
+    {
+        return request(mtd, path_query_fragment, body_data, "text/plain; charset=utf-8", token);
+    }
+
+    /// <summary>
+    /// Asynchronously sends an HTTP request with a string body. Assumes the
+    /// character encoding of the string is UTF-8.
+    /// </summary>
+    /// <param name="mtd">HTTP request method.</param>
+    /// <param name="path_query_fragment">String containing the path, query, and fragment, relative to the http_client's base URI.</param>
+    /// <param name="body_data">String containing the text to use in the message body.</param>
+    /// <param name="token">Cancellation token for cancellation of this request operation.</param>
+    /// <returns>An asynchronous operation that is completed once a response from the request is received.</returns>
+    pplx::task<http_response> request(
+        const method &mtd,
+        const utf8string &path_query_fragment,
+        utf8string &&body_data,
+        const pplx::cancellation_token &token)
+    {
+        http_request msg(mtd);
+        msg.set_request_uri(::utility::conversions::to_string_t(path_query_fragment));
+        msg.set_body(std::move(body_data), "text/plain; charset=utf-8");
+        return request(msg, token);
+    }
+
+    /// <summary>
+    /// Asynchronously sends an HTTP request with a string body. Assumes
+    /// the character encoding of the string is UTF-16 will perform conversion to UTF-8.
+    /// </summary>
+    /// <param name="mtd">HTTP request method.</param>
+    /// <param name="path_query_fragment">String containing the path, query, and fragment, relative to the http_client's base URI.</param>
+    /// <param name="body_data">String containing the text to use in the message body.</param>
+    /// <param name="token">Cancellation token for cancellation of this request operation.</param>
+    /// <returns>An asynchronous operation that is completed once a response from the request is received.</returns>
+    pplx::task<http_response> request(
+        const method &mtd,
+        const utf16string &path_query_fragment,
+        const utf16string &body_data,
         const pplx::cancellation_token &token)
     {
         return request(mtd, path_query_fragment, body_data, _XPLATSTR("text/plain"), token);