Headless (breaking change): A better GenericURLRequestJob::Delegate API

headless/public/util/http_url_fetcher.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "headless/public/util/http_url_fetcher.h"
 
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace headless {
 
 class HttpURLFetcher::Delegate : public net::URLRequest::Delegate {
  public:
   Delegate(const GURL& rewritten_url,
            const std::string& method,
+           const std::string& post_data,
            const net::HttpRequestHeaders& request_headers,
            const net::URLRequestContext* url_request_context,
            ResultListener* result_listener);
   ~Delegate() override;
 
   // URLRequest::Delegate methods:
   void OnAuthRequired(net::URLRequest* request,
                       net::AuthChallengeInfo* auth_info) override;
   void OnSSLCertificateError(net::URLRequest* request,
                              const net::SSLInfo& ssl_info,
@@ skipping 20 matching lines @@
   // Holds the bytes read so far.
   std::string bytes_read_so_far_;
 
   // The interface kn which to report any results.
   ResultListener* result_listener_;  // NOT OWNED.
 };
 
 HttpURLFetcher::Delegate::Delegate(
     const GURL& rewritten_url,
     const std::string& method,
+    const std::string& post_data,
     const net::HttpRequestHeaders& request_headers,
     const net::URLRequestContext* url_request_context,
     ResultListener* result_listener)
     : result_code_(net::OK),
       buf_(new net::IOBuffer(kBufSize)),
       request_(url_request_context->CreateRequest(rewritten_url,
                                                   net::DEFAULT_PRIORITY,
                                                   this)),
       result_listener_(result_listener) {
   request_->set_method(method);
+
+  if (!post_data.empty()) {
+    request_->set_upload(net::ElementsUploadDataStream::CreateWithReader(
+        base::MakeUnique<net::UploadBytesElementReader>(post_data.data(),
+                                                        post_data.size()),
+        0));
+  }
+
   request_->SetExtraRequestHeaders(request_headers);
   request_->Start();
 }
 
 HttpURLFetcher::Delegate::~Delegate() {}
 
 void HttpURLFetcher::Delegate::OnAuthRequired(
     net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request, request_.get());
@@ skipping 97 matching lines @@
 }
 
 HttpURLFetcher::HttpURLFetcher(
     const net::URLRequestContext* url_request_context)
     : url_request_context_(url_request_context) {}
 
 HttpURLFetcher::~HttpURLFetcher() {}
 
 void HttpURLFetcher::StartFetch(const GURL& rewritten_url,
                                 const std::string& method,
+                                const std::string& post_data,
                                 const net::HttpRequestHeaders& request_headers,
-                                const std::string& devtools_request_id,
                                 ResultListener* result_listener) {
-  delegate_.reset(new Delegate(rewritten_url, method, request_headers,
-                               url_request_context_, result_listener));
+  delegate_.reset(new Delegate(rewritten_url, method, post_data,
+                               request_headers, url_request_context_,
+                               result_listener));
 }
 
 }  // namespace headless