Make WebURLLoader capable of retaining received buffers.

content/child/resource_dispatcher.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file_path.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
+#include "content/child/ref_counted_shared_memory.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/child/site_isolation_policy.h"
 #include "content/child/sync_load_response.h"
 #include "content/child/threaded_data_provider.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/resource_messages.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/resource_type.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 
 namespace content {
 
 namespace {
 
+class SharedMemoryReceivedData final : public RequestPeer::ReceivedData {
+ public:
+  SharedMemoryReceivedData(const char* payload,
+                           int length,
+                           int encoded_length,
+                           IPC::Sender* message_sender,
+                           int request_id,
+                           scoped_refptr<RefCountedSharedMemory> shm_buffer)
+      : payload_(payload),
+        length_(length),
+        encoded_length_(encoded_length),
+        message_sender_(message_sender),
+        request_id_(request_id),
+        shm_buffer_(shm_buffer) {}
+  ~SharedMemoryReceivedData() override {
+    message_sender_->Send(new ResourceHostMsg_DataReceived_ACK(request_id_));
+  }
+
+  const char* payload() const override { return payload_; }
+  int length() const override { return length_; }
+  int encoded_length() const override { return encoded_length_; }
+
+ private:
+  const char* const payload_;
+  const int length_;
+  const int encoded_length_;
+
+  // We assume that |message_sender_| outlives this object. This is true because
+  // the sender is provided from |ResourceDispatcher::sender_| and it's a
+  // ChildThreadImpl.
+  IPC::Sender* const message_sender_;
+  const int request_id_;
+  // Just to keep |payload_| alive while this object is alive.
+  scoped_refptr<RefCountedSharedMemory> shm_buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharedMemoryReceivedData);
+};
+
 // Converts |time| from a remote to local TimeTicks, overwriting the original
 // value.
 void RemoteToLocalTimeTicks(
     const InterProcessTimeTicksConverter& converter,
     base::TimeTicks* time) {
   RemoteTimeTicks remote_time = RemoteTimeTicks::FromTimeTicks(*time);
   *time = converter.ToLocalTimeTicks(remote_time).ToTimeTicks();
 }
 
 void CrashOnMapFailure() {
@@ skipping 133 matching lines @@
                                          int shm_size,
                                          base::ProcessId renderer_pid) {
   TRACE_EVENT0("loader", "ResourceDispatcher::OnSetDataBuffer");
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
   CHECK((shm_valid && shm_size > 0) || (!shm_valid && !shm_size));
 
-  request_info->buffer.reset(
-      new base::SharedMemory(shm_handle, true));  // read only
+  request_info->buffer = make_scoped_refptr(
+      new RefCountedSharedMemory(shm_handle, true));  // read only
 
-  bool ok = request_info->buffer->Map(shm_size);
+  bool ok = request_info->buffer->memory().Map(shm_size);
   if (!ok) {
     // Added to help debug crbug/160401.
     base::ProcessId renderer_pid_copy = renderer_pid;
     base::debug::Alias(&renderer_pid_copy);
 
     base::SharedMemoryHandle shm_handle_copy = shm_handle;
     base::debug::Alias(&shm_handle_copy);
 
     CrashOnMapFailure();
     return;
   }
 
   request_info->buffer_size = shm_size;
 }
 
 void ResourceDispatcher::OnReceivedData(int request_id,
                                         int data_offset,
                                         int data_length,
                                         int encoded_data_length) {
   TRACE_EVENT0("loader", "ResourceDispatcher::OnReceivedData");
   DCHECK_GT(data_length, 0);
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   bool send_ack = true;
   if (request_info && data_length > 0) {
-    CHECK(base::SharedMemory::IsHandleValid(request_info->buffer->handle()));
+    CHECK(base::SharedMemory::IsHandleValid(
+        request_info->buffer->memory().handle()));
     CHECK_GE(request_info->buffer_size, data_offset + data_length);
 
     // Ensure that the SHM buffer remains valid for the duration of this scope.
     // It is possible for Cancel() to be called before we exit this scope.
-    linked_ptr<base::SharedMemory> retain_buffer(request_info->buffer);
+    scoped_refptr<RefCountedSharedMemory> retain_buffer(request_info->buffer);
 
     base::TimeTicks time_start = base::TimeTicks::Now();
 
-    const char* data_start = static_cast<char*>(request_info->buffer->memory());
+    const char* data_start =
+        static_cast<char*>(request_info->buffer->memory().memory());
     CHECK(data_start);
     CHECK(data_start + data_offset);
     const char* data_ptr = data_start + data_offset;
 
     // Check whether this response data is compliant with our cross-site
     // document blocking policy. We only do this for the first packet.
     std::string alternative_data;
     if (request_info->site_isolation_metadata.get()) {
       request_info->blocked_response =
           SiteIsolationPolicy::ShouldBlockResponse(
@@ skipping 12 matching lines @@
     }
 
     if (!request_info->blocked_response || !alternative_data.empty()) {
       if (request_info->threaded_data_provider) {
         request_info->threaded_data_provider->OnReceivedDataOnForegroundThread(
             data_ptr, data_length, encoded_data_length);
         // A threaded data provider will take care of its own ACKing, as the
         // data may be processed later on another thread.
         send_ack = false;
       } else {
+        // The SharedMemoryReceivedData sends the ack signal on destruction.
+        send_ack = false;
+        // It's OK to pass the buffer because we don't use |data_ptr| in this
+        // function from now.
         request_info->peer->OnReceivedData(
-            data_ptr, data_length, encoded_data_length);
+            make_scoped_ptr(new SharedMemoryReceivedData(
+                data_ptr, data_length, encoded_data_length, message_sender_,
+                request_id, retain_buffer.Pass())));
       }
     }
 
     UMA_HISTOGRAM_TIMES("ResourceDispatcher.OnReceivedDataTime",
                         base::TimeTicks::Now() - time_start);
   }
 
   // Acknowledge the reception of this data.
   if (send_ack)
     message_sender_->Send(new ResourceHostMsg_DataReceived_ACK(request_id));
@@ skipping 54 matching lines @@
 
 void ResourceDispatcher::OnRequestComplete(
     int request_id,
     const ResourceMsg_RequestCompleteData& request_complete_data) {
   TRACE_EVENT0("loader", "ResourceDispatcher::OnRequestComplete");
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
   request_info->completion_time = ConsumeIOTimestamp();
-  request_info->buffer.reset();
+  request_info->buffer = nullptr;
   request_info->buffer_size = 0;
 
   RequestPeer* peer = request_info->peer;
 
   if (delegate_) {
     RequestPeer* new_peer =
         delegate_->OnRequestComplete(
             request_info->peer, request_info->resource_type,
             request_complete_data.error_code);
     if (new_peer)
@@ skipping 446 matching lines @@
       extra_data->transferred_request_request_id();
   request->service_worker_provider_id =
       extra_data->service_worker_provider_id();
   request->request_body = request_body;
   if (frame_origin)
     *frame_origin = extra_data->frame_origin();
   return request.Pass();
 }
 
 }  // namespace content