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

content/browser/renderer_host/resource_dispatcher_host_unittest.cc

Index: content/browser/renderer_host/resource_dispatcher_host_unittest.cc
===================================================================
--- content/browser/renderer_host/resource_dispatcher_host_unittest.cc	(revision 157294)
+++ content/browser/renderer_host/resource_dispatcher_host_unittest.cc	(working copy)
@@ -75,6 +75,7 @@
     case ResourceMsg_UploadProgress::ID:
     case ResourceMsg_ReceivedResponse::ID:
     case ResourceMsg_ReceivedRedirect::ID:
+    case ResourceMsg_SetDataBuffer::ID:
     case ResourceMsg_DataReceived::ID:
     case ResourceMsg_RequestComplete::ID:
       request_id = IPC::MessageIterator(msg).NextInt();
@@ -736,40 +737,48 @@
                             const std::string& reference_data) {
   // A successful request will have received 4 messages:
   //     ReceivedResponse    (indicates headers received)
-  //     DataReceived        (data)
-  //    XXX DataReceived        (0 bytes remaining from a read)
+  //     SetDataBuffer       (contains shared memory handle)
+  //     DataReceived        (data offset and length into shared memory)
   //     RequestComplete     (request is done)
   //
   // This function verifies that we received 4 messages and that they
   // are appropriate.
-  ASSERT_EQ(3U, messages.size());
+  ASSERT_EQ(4U, messages.size());
 
   // The first messages should be received response
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
-  // followed by the data, currently we only do the data in one chunk, but
-  // should probably test multiple chunks later
-  ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[1].type());
+  ASSERT_EQ(ResourceMsg_SetDataBuffer::ID, messages[1].type());
 
   PickleIterator iter(messages[1]);
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &request_id));
   base::SharedMemoryHandle shm_handle;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_handle));
-  uint32 data_len;
-  ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &data_len));
+  int shm_size;
+  ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_size));
 
-  ASSERT_EQ(reference_data.size(), data_len);
+  // Followed by the data, currently we only do the data in one chunk, but
+  // should probably test multiple chunks later
+  ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2].type());
+
+  PickleIterator iter2(messages[2]);
+  ASSERT_TRUE(IPC::ReadParam(&messages[2], &iter2, &request_id));
+  int data_offset;
+  ASSERT_TRUE(IPC::ReadParam(&messages[2], &iter2, &data_offset));
+  int data_length;
+  ASSERT_TRUE(IPC::ReadParam(&messages[2], &iter2, &data_length));
+
+  ASSERT_EQ(reference_data.size(), static_cast<size_t>(data_length));
+  ASSERT_GE(shm_size, data_length);
+
   base::SharedMemory shared_mem(shm_handle, true);  // read only
-  shared_mem.Map(data_len);
-  const char* data = static_cast<char*>(shared_mem.memory());
-  ASSERT_EQ(0, memcmp(reference_data.c_str(), data, data_len));
+  shared_mem.Map(data_length);
+  const char* data = static_cast<char*>(shared_mem.memory()) + data_offset;
+  ASSERT_EQ(0, memcmp(reference_data.c_str(), data, data_length));
 
-  // followed by a 0-byte read
-  //ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2].type());
-
-  // the last message should be all data received
-  ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[2].type());
+  // The last message should be all data received.
+  ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[3].type());
 }
 
 // Tests whether many messages get dispatched properly.
@@ -1798,7 +1807,8 @@
   size_t size = msgs[0].size();
 
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
-  for (size_t i = 1; i < size - 1; ++i)
+  EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
+  for (size_t i = 2; i < size - 1; ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][size - 1].type());
 }
@@ -1813,9 +1823,10 @@
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
-  // We expect 1x ReceivedResponse + Nx ReceivedData messages.
+  // We expect 1x ReceivedResponse, 1x SetDataBuffer, Nx ReceivedData messages.
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
-  for (size_t i = 1; i < msgs[0].size(); ++i)
+  EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type());
+  for (size_t i = 2; i < msgs[0].size(); ++i)
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
   // NOTE: If we fail the above checks then it means that we probably didn't
@@ -1823,6 +1834,7 @@
   // test!
 
   msgs[0].erase(msgs[0].begin());
+  msgs[0].erase(msgs[0].begin());
 
   // ACK all DataReceived messages until we find a RequestComplete message.
   bool complete = false;