Unified write data API binding (#839)

Co-authored-by: sbiscigl <sbiscigl@amazon.com>

Author: azkrishpy

crt/aws-c-http

@@ -10,6 +10,7 @@
 #include <aws/crt/Types.h>
 #include <aws/crt/io/Bootstrap.h>
 #include <aws/crt/io/SocketOptions.h>
+#include <aws/crt/io/Stream.h>
 #include <aws/crt/io/TlsOptions.h>
 
 #include <functional>
@@ -118,6 +119,27 @@ namespace Aws
                  * See `OnStreamComplete` for more info. This value can be empty.
                  */
                 OnStreamComplete onStreamComplete;
+
+                /**
+                 * When true, request body data will be provided over time via `HttpClientStream::WriteData()`
+                 * The stream will only be polled for writing when data has been supplied.
+                 * When false (default), the entire request body is read from the input stream immediately.
+                 *
+                 * HTTP/1.1 requirements:
+                 * - SHOULD have either `Content-Length` OR `Transfer-Encoding: chunked` header (but not both).
+                 *   Fails with AWS_ERROR_HTTP_INVALID_HEADER_FIELD if both are set.
+                 *   Transfer-Encoding: chunked header will be automatically added if neither header is set.
+                 * - MUST NOT have a body stream set. Fails with AWS_ERROR_HTTP_INVALID_HEADER_FIELD otherwise.
+                 * - With `Content-Length`: total bytes written must exactly match the declared length.
+                 *   Fails with AWS_ERROR_HTTP_OUTGOING_STREAM_LENGTH_INCORRECT if data exceeds Content-Length,
+                 *   or if `end_stream` is set before enough data is written.
+                 * - With `Transfer-Encoding: chunked`: no length validation, data sent as chunks.
+                 *
+                 * HTTP/2: No `Content-Length` or `Transfer-Encoding` header required. Data sent via DATA frames.
+                 * Note: When this variable is set, we expect request to be ended with a data write with
+                 * end_stream=true.
+                 */
+                bool UseManualDataWrites = false;
             };
 
             /**
@@ -191,6 +213,8 @@ namespace Aws
                 std::shared_ptr<HttpStream> stream;
             };
 
+            using OnWriteDataComplete = std::function<void(std::shared_ptr<HttpStream> &stream, int errorCode)>;
+
             /**
              * Subclass that represents an http client's view of an HttpStream.
              */
@@ -216,6 +240,11 @@ namespace Aws
                  */
                 bool Activate() noexcept;
 
+                int WriteData(
+                    std::shared_ptr<Aws::Crt::Io::InputStream> stream,
+                    const OnWriteDataComplete &onComplete,
+                    bool endStream = false) noexcept;
+
               private:
                 HttpClientStream(const std::shared_ptr<HttpClientConnection> &connection) noexcept;
 

include/aws/crt/http/HttpConnection.h

@@ -202,6 +202,7 @@ namespace Aws
                 options.on_response_headers = HttpStream::s_onIncomingHeaders;
                 options.on_response_header_block_done = HttpStream::s_onIncomingHeaderBlockDone;
                 options.on_complete = HttpStream::s_onStreamComplete;
+                options.use_manual_data_writes = requestOptions.UseManualDataWrites;
 
                 /* Do the same ref counting trick we did with HttpClientConnection. We need to maintain a reference
                  * internally (regardless of what the user does), until the Stream shuts down. */
@@ -361,6 +362,35 @@ namespace Aws
                 return true;
             }
 
+            struct OnWriteUserData
+            {
+                Aws::Crt::Http::OnWriteDataComplete callback;
+                Aws::Crt::Http::ClientStreamCallbackData callbackData;
+            };
+
+            int HttpClientStream::WriteData(
+                std::shared_ptr<Aws::Crt::Io::InputStream> stream,
+                const OnWriteDataComplete &onComplete,
+                bool endStream) noexcept
+            {
+                aws_http_stream_write_data_options options{};
+                options.data = stream->GetUnderlyingStream();
+                options.end_stream = endStream;
+                options.on_complete = +[](struct aws_http_stream *, int error_code, void *user_data)
+                {
+                    auto *userData = static_cast<OnWriteUserData *>(user_data);
+                    userData->callback(userData->callbackData.stream, error_code);
+                    Aws::Crt::Delete(userData, userData->callbackData.allocator);
+                };
+
+                auto *data = Aws::Crt::New<OnWriteUserData>(m_callbackData.allocator);
+                data->callback = onComplete;
+                data->callbackData = m_callbackData;
+                options.user_data = data;
+
+                return aws_http_stream_write_data(m_stream, &options);
+            }
+
             void HttpStream::UpdateWindow(std::size_t incrementSize) noexcept
             {
                 aws_http_stream_update_window(m_stream, incrementSize);