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

content/browser/loader/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 <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 690 matching lines @@
     delay_complete_ = delay_job_complete;
   }
 
   void GenerateDataReceivedACK(const IPC::Message& msg) {
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msg.type());
 
     int request_id = -1;
     bool result = PickleIterator(msg).ReadInt(&request_id);
     DCHECK(result);
     scoped_ptr<IPC::Message> ack(
-        new ResourceHostMsg_DataReceived_ACK(msg.routing_id(), request_id));
+        new ResourceHostMsg_DataReceived_ACK(request_id));
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&GenerateIPCMessage, filter_, base::Passed(&ack)));
   }
 
   base::MessageLoopForIO message_loop_;
   BrowserThreadImpl ui_thread_;
   BrowserThreadImpl file_thread_;
   BrowserThreadImpl cache_thread_;
@@ skipping 880 matching lines @@
   SetResourceType(ResourceType::MAIN_FRAME);
   SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
   // Return some data so that the request is identified as a download
   // and the proper resource handlers are created.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
 
   // And now simulate a cancellation coming from the renderer.
-  ResourceHostMsg_CancelRequest msg(filter_->child_id(), request_id);
+  ResourceHostMsg_CancelRequest msg(request_id);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
 
   // Since the request had already started processing as a download,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 }
@@ skipping 14 matching lines @@
   SetResourceType(ResourceType::MAIN_FRAME);
   SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
   // Return some data so that the request is identified as a download
   // and the proper resource handlers are created.
   EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage());
 
   // And now simulate a cancellation coming from the renderer.
-  ResourceHostMsg_CancelRequest msg(filter_->child_id(), request_id);
+  ResourceHostMsg_CancelRequest msg(request_id);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
 
   // Since the request had already started processing as a download,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by other methods shouldn't work either.
   host_.CancelRequestsForProcess(render_view_id);
@@ skipping 20 matching lines @@
   SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
 
   GlobalRequestID global_request_id(filter_->child_id(), request_id);
   host_.MarkAsTransferredNavigation(global_request_id,
                                     GURL("http://example.com/blah"));
 
   // And now simulate a cancellation coming from the renderer.
-  ResourceHostMsg_CancelRequest msg(filter_->child_id(), request_id);
+  ResourceHostMsg_CancelRequest msg(request_id);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
 
   // Since the request is marked as being transferred,
   // the cancellation above should have been ignored and the request
   // should still be alive.
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by other methods shouldn't work either.
   host_.CancelRequestsForProcess(render_view_id);
@@ skipping 126 matching lines @@
   // OK, let the redirect happen.
   SetDelayedStartJobGeneration(false);
   CompleteStartRequest(second_filter.get(), new_request_id);
   base::MessageLoop::current()->RunUntilIdle();
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Now, simulate the renderer choosing to follow the redirect.
   ResourceHostMsg_FollowRedirect redirect_msg(
-      new_render_view_id, new_request_id, false, GURL());
+      new_request_id, false, GURL());
   host_.OnMessageReceived(redirect_msg, second_filter.get(), &msg_was_ok);
   base::MessageLoop::current()->RunUntilIdle();
 
   // Flush all the pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   // Check generated messages.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
@@ skipping 85 matching lines @@
   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);
+      ResourceHostMsg_DataReceived_ACK msg(1);
       bool msg_was_ok;
       host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
     }
 
     base::MessageLoop::current()->RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
@@ skipping 14 matching lines @@
   EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   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.
 
   // Send some unexpected ACKs.
   for (size_t i = 0; i < 128; ++i) {
-    ResourceHostMsg_DataReceived_ACK msg(0, 1);
+    ResourceHostMsg_DataReceived_ACK msg(1);
     bool msg_was_ok;
     host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
   }
 
   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);
+      ResourceHostMsg_DataReceived_ACK msg(1);
       bool msg_was_ok;
       host_.OnMessageReceived(msg, filter_.get(), &msg_was_ok);
     }
 
     base::MessageLoop::current()->RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content