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

content/browser/renderer_host/resource_dispatcher_host_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 "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 57 matching lines @@
 }
 
 }  // namespace
 
 static int RequestIDForMessage(const IPC::Message& msg) {
   int request_id = -1;
   switch (msg.type()) {
     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();
       break;
   }
   return request_id;
 }
 
 static ResourceHostMsg_Request CreateResourceRequest(
     const char* method,
@@ skipping 641 matching lines @@
   net::URLRequest* req = host_.GetURLRequest(gid);
   EXPECT_TRUE(req);
   if (req)
     URLRequestTestDelayedStartJob::CompleteStart(req);
 }
 
 void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages,
                             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.
 TEST_F(ResourceDispatcherHostTest, TestMany) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3());
 
@@ skipping 1008 matching lines @@
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   // Sort all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   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());
 }
 
 TEST_F(ResourceDispatcherHostTest, DelayedDataReceivedACKs) {
   EXPECT_EQ(0, host_.pending_requests());
 
   HandleScheme("big-job");
   MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000"));
 
   // Sort all the messages we saw by request.
   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
   // load a big enough response to trigger the delay mechanism we are trying to
   // 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;
   while (!complete) {
     for (size_t i = 0; i < msgs[0].size(); ++i) {
       if (msgs[0][i].type() == ResourceMsg_RequestComplete::ID) {
         complete = true;
         break;
       }
 
       EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type());
 
       ResourceHostMsg_DataReceived_ACK msg(0, 1);
       bool msg_was_ok;
       host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
     }
 
     MessageLoop::current()->RunAllPending();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content