Modify AsyncResourceHandler to use a single shared memory buffer (in ring

content/common/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/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/request_extra_data.h"
 #include "content/common/resource_messages.h"
 #include "content/public/common/resource_dispatcher_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/http_response_headers.h"
@@ skipping 293 matching lines @@
 void ResourceDispatcher::OnReceivedCachedMetadata(
       int request_id, const std::vector<char>& data) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   if (data.size())
     request_info->peer->OnReceivedCachedMetadata(&data.front(), data.size());
 }
 
+void ResourceDispatcher::OnSetDataBuffer(const IPC::Message& message,
+                                         int request_id,
+                                         base::SharedMemoryHandle shm_handle,
+                                         int shm_size) {
+  PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
+  if (!request_info)
+    return;
+
+  bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
+  DCHECK((shm_valid && shm_size > 0) || (!shm_valid && !shm_size));
+
+  request_info->buffer.reset(
+      new base::SharedMemory(shm_handle, true));  // read only
+  request_info->buffer->Map(shm_size);
+}
+
 void ResourceDispatcher::OnReceivedData(const IPC::Message& message,
                                         int request_id,
-                                        base::SharedMemoryHandle shm_handle,
-                                        int data_len,
+                                        int data_offset,
+                                        int data_length,
                                         int encoded_data_length) {
+  PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
+  if (request_info && data_length > 0) {
+    base::TimeTicks time_start = base::TimeTicks::Now();
+
+    request_info->peer->OnReceivedData(
+        static_cast<char*>(request_info->buffer->memory()) + data_offset,
+        data_length,
+        encoded_data_length);
+
+    UMA_HISTOGRAM_TIMES("ResourceDispatcher.OnReceivedDataTime",
+                        base::TimeTicks::Now() - time_start);
+  }
+
   // Acknowledge the reception of this data.
   message_sender()->Send(
       new ResourceHostMsg_DataReceived_ACK(message.routing_id(), request_id));
-
-  const bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
-  DCHECK((shm_valid && data_len > 0) || (!shm_valid && !data_len));
-  base::SharedMemory shared_mem(shm_handle, true);  // read only
-
-  PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
-  if (!request_info)
-    return;
-
-  if (data_len > 0 && shared_mem.Map(data_len)) {
-    const char* data = static_cast<char*>(shared_mem.memory());
-    request_info->peer->OnReceivedData(data, data_len, encoded_data_length);
-  }
 }
 
 void ResourceDispatcher::OnDownloadedData(const IPC::Message& message,
                                           int request_id,
                                           int data_len) {
   // Acknowledge the reception of this message.
   message_sender()->Send(
       new ResourceHostMsg_DataDownloaded_ACK(message.routing_id(), request_id));
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
@@ skipping 49 matching lines @@
 void ResourceDispatcher::OnRequestComplete(
     int request_id,
     int error_code,
     bool was_ignored_by_handler,
     const std::string& security_info,
     const base::TimeTicks& browser_completion_time) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
   request_info->completion_time = base::TimeTicks::Now();
+  request_info->buffer.reset();
 
   ResourceLoaderBridge::Peer* peer = request_info->peer;
 
   if (delegate_) {
     ResourceLoaderBridge::Peer* new_peer =
         delegate_->OnRequestComplete(
             request_info->peer, request_info->resource_type, error_code);
     if (new_peer)
       request_info->peer = new_peer;
   }
@@ skipping 85 matching lines @@
 
 ResourceDispatcher::PendingRequestInfo::~PendingRequestInfo() {}
 
 void ResourceDispatcher::DispatchMessage(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(ResourceDispatcher, message)
     IPC_MESSAGE_HANDLER(ResourceMsg_UploadProgress, OnUploadProgress)
     IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedResponse, OnReceivedResponse)
     IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedCachedMetadata,
                         OnReceivedCachedMetadata)
     IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedRedirect, OnReceivedRedirect)
+    IPC_MESSAGE_HANDLER(ResourceMsg_SetDataBuffer, OnSetDataBuffer)
     IPC_MESSAGE_HANDLER(ResourceMsg_DataReceived, OnReceivedData)
     IPC_MESSAGE_HANDLER(ResourceMsg_DataDownloaded, OnDownloadedData)
     IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestComplete)
   IPC_END_MESSAGE_MAP()
 }
 
 void ResourceDispatcher::FlushDeferredMessages(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())  // The request could have become invalid.
     return;
@@ skipping 89 matching lines @@
 }
 
 // static
 bool ResourceDispatcher::IsResourceDispatcherMessage(
     const IPC::Message& message) {
   switch (message.type()) {
     case ResourceMsg_UploadProgress::ID:
     case ResourceMsg_ReceivedResponse::ID:
     case ResourceMsg_ReceivedCachedMetadata::ID:
     case ResourceMsg_ReceivedRedirect::ID:
+    case ResourceMsg_SetDataBuffer::ID:
     case ResourceMsg_DataReceived::ID:
     case ResourceMsg_DataDownloaded::ID:
     case ResourceMsg_RequestComplete::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }
 
 // static
 void ResourceDispatcher::ReleaseResourcesInDataMessage(
     const IPC::Message& message) {
   PickleIterator iter(message);
   int request_id;
   if (!message.ReadInt(&iter, &request_id)) {
     NOTREACHED() << "malformed resource message";
     return;
   }
 
-  // If the message contains a shared memory handle, we should close the
-  // handle or there will be a memory leak.
-  if (message.type() == ResourceMsg_DataReceived::ID) {
+  // If the message contains a shared memory handle, we should close the handle
+  // or there will be a memory leak.
+  if (message.type() == ResourceMsg_SetDataBuffer::ID) {
     base::SharedMemoryHandle shm_handle;
     if (IPC::ParamTraits<base::SharedMemoryHandle>::Read(&message,
                                                          &iter,
                                                          &shm_handle)) {
-      base::SharedMemory::CloseHandle(shm_handle);
+      if (base::SharedMemory::IsHandleValid(shm_handle))
+        base::SharedMemory::CloseHandle(shm_handle);
     }
   }
 }
 
 // static
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }
 
 }  // namespace content