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

content/common/resource_dispatcher_unittest.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.
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process.h"
@@ skipping 116 matching lines @@
       dispatcher_->OnReceivedResponse(request_id, response);
 
       // received data message with the test contents
       base::SharedMemory shared_mem;
       EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len));
       char* put_data_here = static_cast<char*>(shared_mem.memory());
       memcpy(put_data_here, test_page_contents, test_page_contents_len);
       base::SharedMemoryHandle dup_handle;
       EXPECT_TRUE(shared_mem.GiveToProcess(
           base::Process::Current().handle(), &dup_handle));
-      dispatcher_->OnReceivedData(
-          message_queue_[0],
-          request_id,
-          dup_handle,
-          test_page_contents_len,
-          test_page_contents_len);
+      dispatcher_->OnSetDataBuffer(message_queue_[0], request_id, dup_handle,
+                                   test_page_contents_len);
+      dispatcher_->OnReceivedData(message_queue_[0], request_id, 0,
+                                  test_page_contents_len,
+                                  test_page_contents_len);
 
       message_queue_.erase(message_queue_.begin());
 
       // read the ack message.
       Tuple1<int> request_ack;
       ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
           &message_queue_[0], &request_ack));
 
       ASSERT_EQ(request_ack.a, request_id);
 
@@ skipping 100 matching lines @@
     dispatcher_->OnMessageReceived(
         ResourceMsg_ReceivedResponse(0, 0, response_head));
 
     // Duplicate the shared memory handle so both the test and the callee can
     // close their copy.
     base::SharedMemoryHandle duplicated_handle;
     EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
                                               &duplicated_handle));
 
     dispatcher_->OnMessageReceived(
-        ResourceMsg_DataReceived(0, 0, duplicated_handle, 100, 100));
+        ResourceMsg_SetDataBuffer(0, 0, duplicated_handle, 100));
+    dispatcher_->OnMessageReceived(
+        ResourceMsg_DataReceived(0, 0, 0, 100, 100));
 
     set_defer_loading(false);
   }
 
   // ResourceLoaderBridge::Peer methods.
   virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
   }
 
   virtual bool OnReceivedRedirect(
       const GURL& new_url,
@@ skipping 153 matching lines @@
   ResourceResponseHead response_head;
   response_head.error_code = net::OK;
 
   PerformTest(response_head);
 
   EXPECT_EQ(0, response_info().load_timing.base_ticks.ToInternalValue());
   EXPECT_EQ(-1, response_info().load_timing.dns_start);
 }
 
 }  // namespace content