Convert a bunch of resource IPCs to be control messages. They didn't need to be routed.

content/child/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/message_loop.h"
 #include "base/process/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_->OnSetDataBuffer(message_queue_[0], request_id, dup_handle,
+      dispatcher_->OnSetDataBuffer(request_id, dup_handle,
                                    test_page_contents_len, 0);
-      dispatcher_->OnReceivedData(message_queue_[0], request_id, 0,
-                                  test_page_contents_len,
+      dispatcher_->OnReceivedData(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 93 matching lines @@
     return true;
   }
 
   void InitMessages() {
     set_defer_loading(true);
 
     ResourceResponseHead response_head;
     response_head.error_code = net::OK;
 
     dispatcher_->OnMessageReceived(
-        ResourceMsg_ReceivedResponse(0, 0, response_head));
+        ResourceMsg_ReceivedResponse(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_SetDataBuffer(0, 0, duplicated_handle, 100, 0));
-    dispatcher_->OnMessageReceived(
-        ResourceMsg_DataReceived(0, 0, 0, 100, 100));
+        ResourceMsg_SetDataBuffer(0, duplicated_handle, 100, 0));
+    dispatcher_->OnMessageReceived(ResourceMsg_DataReceived(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 72 matching lines @@
   virtual bool Send(IPC::Message* msg) OVERRIDE {
     delete msg;
     return true;
   }
 
   void PerformTest(const ResourceResponseHead& response_head) {
     scoped_ptr<ResourceLoaderBridge> bridge(CreateBridge());
     bridge->Start(this);
 
     dispatcher_->OnMessageReceived(
-        ResourceMsg_ReceivedResponse(0, 0, response_head));
+        ResourceMsg_ReceivedResponse(0, response_head));
   }
 
   // ResourceLoaderBridge::Peer methods.
   virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
   }
 
   virtual bool OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
       bool* has_new_first_party_for_cookies,
@@ skipping 65 matching lines @@
   response_head.error_code = net::OK;
 
   PerformTest(response_head);
 
   EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
   EXPECT_EQ(base::TimeTicks(),
             response_info().load_timing.connect_timing.dns_start);
 }
 
 }  // namespace content