Make WebURLLoader capable of retaining received buffers.

content/child/web_url_loader_impl.cc

 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
 
 #include <algorithm>
 #include <deque>
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "components/mime_util/mime_util.h"
 #include "content/child/child_thread_impl.h"
@@ skipping 48 matching lines @@
 namespace content {
 
 // Utilities ------------------------------------------------------------------
 
 namespace {
 
 const size_t kBodyStreamPipeCapacity = 4 * 1024;
 
 typedef ResourceDevToolsInfo::HeadersVector HeadersVector;
 
+class FixedReceivedData final : public RequestPeer::ReceivedData {
+ public:
+  FixedReceivedData(const char* payload, int length, int encoded_length)
+      : data_(&payload[0], &payload[length]), encoded_length_(encoded_length) {}
+  ~FixedReceivedData() override {}
+
+  const char* payload() const override {
+    // TODO(yhirano): Use |data_.data()| when we can use c++11.
+    return data_.empty() ? nullptr : &data_[0];
+  }
+  int length() const override { return data_.size(); }
+  int encoded_length() const override { return encoded_length_; }
+
+ private:
+  const std::vector<char> data_;
+  const int encoded_length_;
+
+  DISALLOW_COPY_AND_ASSIGN(FixedReceivedData);
+};
+
 // Converts timing data from |load_timing| to the format used by WebKit.
 void PopulateURLLoadTiming(const net::LoadTimingInfo& load_timing,
                            WebURLLoadTiming* url_timing) {
   DCHECK(!load_timing.request_start.is_null());
 
   const TimeTicks kNullTicks;
   url_timing->initialize();
   url_timing->setRequestTime(
       (load_timing.request_start - kNullTicks).InSecondsF());
   url_timing->setProxyStart(
@@ skipping 218 matching lines @@
       blink::WebThreadedDataReceiver* threaded_data_receiver);
   void Start(const WebURLRequest& request,
              SyncLoadResponse* sync_load_response);
 
   // RequestPeer methods:
   void OnUploadProgress(uint64 position, uint64 size) override;
   bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
                           const ResourceResponseInfo& info) override;
   void OnReceivedResponse(const ResourceResponseInfo& info) override;
   void OnDownloadedData(int len, int encoded_data_length) override;
-  void OnReceivedData(const char* data,
-                      int data_length,
-                      int encoded_data_length) override;
+  void OnReceivedData(scoped_ptr<ReceivedData> data) override;
   void OnReceivedCachedMetadata(const char* data, int len) override;
   void OnCompletedRequest(int error_code,
                           bool was_ignored_by_handler,
                           bool stale_copy_in_cache,
                           const std::string& security_info,
                           const base::TimeTicks& completion_time,
                           int64 total_transfer_size) override;
 
  private:
   friend class base::RefCounted<Context>;
@@ skipping 342 matching lines @@
         new FtpDirectoryListingResponseDelegate(client_, loader_, response));
   }
 }
 
 void WebURLLoaderImpl::Context::OnDownloadedData(int len,
                                                  int encoded_data_length) {
   if (client_)
     client_->didDownloadData(loader_, len, encoded_data_length);
 }
 
-void WebURLLoaderImpl::Context::OnReceivedData(const char* data,
-                                               int data_length,
-                                               int encoded_data_length) {
+void WebURLLoaderImpl::Context::OnReceivedData(scoped_ptr<ReceivedData> data) {
+  const char* payload = data->payload();
+  int data_length = data->length();
+  int encoded_data_length = data->encoded_length();
   if (!client_)
     return;
 
   if (request_.useStreamOnResponse()) {
     // We don't support ftp_listening_delegate_ and multipart_delegate_ for now.
     // TODO(yhirano): Support ftp listening and multipart.
-    MojoResult rv = WriteDataOnBodyStream(data, data_length);
+    MojoResult rv = WriteDataOnBodyStream(payload, data_length);
     if (rv != MOJO_RESULT_OK && client_) {
       client_->didFail(
           loader_, CreateWebURLError(request_.url(), false, net::ERR_FAILED));
     }
   } else if (ftp_listing_delegate_) {
     // The FTP listing delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.  Since the
     // delegate may want to do work after sending data to the delegate, keep
     // |this| and the delegate alive until it's finished handling the data.
     scoped_refptr<Context> protect(this);
-    ftp_listing_delegate_->OnReceivedData(data, data_length);
+    ftp_listing_delegate_->OnReceivedData(payload, data_length);
   } else if (multipart_delegate_) {
     // The multipart delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.  Since the
     // delegate may want to do work after sending data to the delegate, keep
     // |this| and the delegate alive until it's finished handling the data.
     scoped_refptr<Context> protect(this);
-    multipart_delegate_->OnReceivedData(data, data_length, encoded_data_length);
+    multipart_delegate_->OnReceivedData(payload, data_length,
+                                        encoded_data_length);
   } else {
-    client_->didReceiveData(loader_, data, data_length, encoded_data_length);
+    client_->didReceiveData(loader_, payload, data_length, encoded_data_length);
   }
 }
 
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (client_)
     client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
@@ skipping 96 matching lines @@
   }
 
   ResourceResponseInfo info;
   std::string data;
 
   int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
 
   if (error_code == net::OK) {
     OnReceivedResponse(info);
     if (!data.empty())
-      OnReceivedData(data.data(), data.size(), 0);
+      OnReceivedData(
+          make_scoped_ptr(new FixedReceivedData(data.data(), data.size(), 0)));
   }
 
   OnCompletedRequest(error_code, false, false, info.security_info,
                      base::TimeTicks::Now(), 0);
 }
 
 MojoResult WebURLLoaderImpl::Context::WriteDataOnBodyStream(const char* data,
                                                             size_t size) {
   if (body_stream_buffer_.empty() && size == 0) {
     // Nothing to do.
@@ skipping 279 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 bool WebURLLoaderImpl::attachThreadedDataReceiver(
     blink::WebThreadedDataReceiver* threaded_data_receiver) {
   return context_->AttachThreadedDataReceiver(threaded_data_receiver);
 }
 
 }  // namespace content