HTTPTransport: callers should be able to obtain the HTTP response body

util/net/http_transport_win.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 55 matching lines @@
   }
 };
 
 using ScopedHINTERNET = base::ScopedGeneric<HINTERNET, ScopedHINTERNETTraits>;
 
 class HTTPTransportWin final : public HTTPTransport {
  public:
   HTTPTransportWin();
   ~HTTPTransportWin() override;
 
-  bool ExecuteSynchronously() override;
+  bool ExecuteSynchronously(std::string* response_body) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HTTPTransportWin);
 };
 
 HTTPTransportWin::HTTPTransportWin() : HTTPTransport() {
 }
 
 HTTPTransportWin::~HTTPTransportWin() {
 }
 
-bool HTTPTransportWin::ExecuteSynchronously() {
+bool HTTPTransportWin::ExecuteSynchronously(std::string* response_body) {
   ScopedHINTERNET session(
       WinHttpOpen(base::UTF8ToUTF16(PACKAGE_NAME "/" PACKAGE_VERSION).c_str(),
                   WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                   WINHTTP_NO_PROXY_NAME,
                   WINHTTP_NO_PROXY_BYPASS,
                   0));
   if (!session.get()) {
     LogErrorWinHttpMessage("WinHttpOpen");
     return false;
   }
@@ skipping 48 matching lines @@
       return false;
     }
   }
 
   // We need the Content-Length up front, so buffer in memory. We should modify
   // the interface to not require this, and then use WinHttpWriteData after
   // WinHttpSendRequest.
   std::vector<uint8_t> post_data;
 
   // Write the body of a POST if any.
+  const size_t kBufferSize = 4096;
   for (;;) {
-    uint8_t buffer[4096];
+    uint8_t buffer[kBufferSize];
     ssize_t bytes_to_write =
         body_stream()->GetBytesBuffer(buffer, sizeof(buffer));
     if (bytes_to_write == 0)
       break;
     post_data.insert(post_data.end(), buffer, buffer + bytes_to_write);
   }
 
   if (!WinHttpSendRequest(request.get(),
                           WINHTTP_NO_ADDITIONAL_HEADERS,
                           0,
@@ skipping 22 matching lines @@
           WINHTTP_NO_HEADER_INDEX)) {
     LogErrorWinHttpMessage("WinHttpQueryHeaders");
     return false;
   }
 
   if (status_code != 200) {
     LOG(ERROR) << base::StringPrintf("HTTP status %d", status_code);
     return false;
   }
 
-  // TODO(scottmg): Retrieve body of response if necessary with
-  // WinHttpQueryDataAvailable and WinHttpReadData.
+  if (response_body) {
+    response_body->clear();
+
+    // There isn’t any reason to call WinHttpQueryDataAvailable(), because it
+    // returns the number of bytes available to be read without blocking at the
+    // time of the call, not the number of bytes until end-of-file. This method,
+    // which executes synchronously, is only concerned with reading until EOF.
+    DWORD bytes_read = 0;
+    do {
+      char read_buffer[kBufferSize];
+      if (!WinHttpReadData(
+              request.get(), read_buffer, sizeof(read_buffer), &bytes_read)) {
+        LogErrorWinHttpMessage("WinHttpReadData");
+        return false;
+      }
+
+      response_body->append(read_buffer, bytes_read);
+    } while (bytes_read > 0);
+  }
 
   return true;
 }
 
 }  // namespace
 
 // static
 scoped_ptr<HTTPTransport> HTTPTransport::Create() {
   return scoped_ptr<HTTPTransportWin>(new HTTPTransportWin);
 }
 
 }  // namespace crashpad