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

content/child/resource_dispatcher.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 182 matching lines @@
       new ResourceHostMsg_RequestResource(routing_id_, request_id_, request_));
 }
 
 void IPCResourceLoaderBridge::Cancel() {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to cancel an unstarted request";
     return;
   }
 
   if (!is_synchronous_request_)
-    dispatcher_->CancelPendingRequest(routing_id_, request_id_);
+    dispatcher_->CancelPendingRequest(request_id_);
 
   // We can't remove the request ID from the resource dispatcher because more
   // data might be pending. Sending the cancel message may cause more data
   // to be flushed, and will then cause a complete message to be sent.
 }
 
 void IPCResourceLoaderBridge::SetDefersLoading(bool value) {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to (un)defer an unstarted request";
     return;
@@ skipping 103 matching lines @@
 ResourceDispatcher::PendingRequestInfo*
 ResourceDispatcher::GetPendingRequestInfo(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     // This might happen for kill()ed requests on the webkit end.
     return NULL;
   }
   return &(it->second);
 }
 
-void ResourceDispatcher::OnUploadProgress(
-    const IPC::Message& message, int request_id, int64 position, int64 size) {
+void ResourceDispatcher::OnUploadProgress(int request_id, int64 position,
+                                          int64 size) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   request_info->peer->OnUploadProgress(position, size);
 
   // Acknowledge receipt
-  message_sender()->Send(
-      new ResourceHostMsg_UploadProgress_ACK(message.routing_id(), request_id));
+  message_sender()->Send(new ResourceHostMsg_UploadProgress_ACK(request_id));
 }
 
 void ResourceDispatcher::OnReceivedResponse(
     int request_id, const ResourceResponseHead& response_head) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
   request_info->response_start = ConsumeIOTimestamp();
 
   if (delegate_) {
@@ skipping 18 matching lines @@
 void ResourceDispatcher::OnReceivedCachedMetadata(
       int request_id, const std::vector<char>& data) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   if (data.size())
     request_info->peer->OnReceivedCachedMetadata(&data.front(), data.size());
 }
 
-void ResourceDispatcher::OnSetDataBuffer(const IPC::Message& message,
-                                         int request_id,
+void ResourceDispatcher::OnSetDataBuffer(int request_id,
                                          base::SharedMemoryHandle shm_handle,
                                          int shm_size,
                                          base::ProcessId renderer_pid) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
   CHECK((shm_valid && shm_size > 0) || (!shm_valid && !shm_size));
 
   request_info->buffer.reset(
       new base::SharedMemory(shm_handle, true));  // read only
 
   bool ok = request_info->buffer->Map(shm_size);
   if (!ok) {
     // Added to help debug crbug/160401.
     base::ProcessId renderer_pid_copy = renderer_pid;
     base::debug::Alias(&renderer_pid_copy);
 
     base::SharedMemoryHandle shm_handle_copy = shm_handle;
     base::debug::Alias(&shm_handle_copy);
 
     CrashOnMapFailure();
     return;
   }
 
   request_info->buffer_size = shm_size;
 }
 
-void ResourceDispatcher::OnReceivedData(const IPC::Message& message,
-                                        int request_id,
+void ResourceDispatcher::OnReceivedData(int request_id,
                                         int data_offset,
                                         int data_length,
                                         int encoded_data_length) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (request_info && data_length > 0) {
     CHECK(base::SharedMemory::IsHandleValid(request_info->buffer->handle()));
     CHECK_GE(request_info->buffer_size, data_offset + data_length);
 
     // Ensure that the SHM buffer remains valid for the duration of this scope.
     // It is possible for CancelPendingRequest() to be called before we exit
@@ skipping 23 matching lines @@
       request_info->peer->OnReceivedData(alternative_data.data(),
                                          alternative_data.size(),
                                          alternative_data.size());
     }
 
     UMA_HISTOGRAM_TIMES("ResourceDispatcher.OnReceivedDataTime",
                         base::TimeTicks::Now() - time_start);
   }
 
   // Acknowledge the reception of this data.
-  message_sender()->Send(
-      new ResourceHostMsg_DataReceived_ACK(message.routing_id(), request_id));
+  message_sender()->Send(new ResourceHostMsg_DataReceived_ACK(request_id));
 }
 
-void ResourceDispatcher::OnDownloadedData(const IPC::Message& message,
-                                          int request_id,
+void ResourceDispatcher::OnDownloadedData(int request_id,
                                           int data_len,
                                           int encoded_data_length) {
   // Acknowledge the reception of this message.
   message_sender()->Send(
-      new ResourceHostMsg_DataDownloaded_ACK(message.routing_id(), request_id));
+      new ResourceHostMsg_DataDownloaded_ACK(request_id));
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   request_info->peer->OnDownloadedData(data_len, encoded_data_length);
 }
 
 void ResourceDispatcher::OnReceivedRedirect(
-    const IPC::Message& message,
     int request_id,
     const GURL& new_url,
     const ResourceResponseHead& response_head) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
   request_info->response_start = ConsumeIOTimestamp();
 
-  int32 routing_id = message.routing_id();
   bool has_new_first_party_for_cookies = false;
   GURL new_first_party_for_cookies;
   ResourceResponseInfo renderer_response_info;
   ToResourceResponseInfo(*request_info, response_head, &renderer_response_info);
   if (request_info->peer->OnReceivedRedirect(new_url, renderer_response_info,
                                              &has_new_first_party_for_cookies,
                                              &new_first_party_for_cookies)) {
     // Double-check if the request is still around. The call above could
     // potentially remove it.
     request_info = GetPendingRequestInfo(request_id);
     if (!request_info)
       return;
     // We update the response_url here so that we can send it to
     // SiteIsolationPolicy later when OnReceivedResponse is called.
     request_info->response_url = new_url;
     request_info->pending_redirect_message.reset(
-        new ResourceHostMsg_FollowRedirect(routing_id, request_id,
+        new ResourceHostMsg_FollowRedirect(request_id,
                                            has_new_first_party_for_cookies,
                                            new_first_party_for_cookies));
     if (!request_info->is_deferred) {
       FollowPendingRedirect(request_id, *request_info);
     }
   } else {
-    CancelPendingRequest(routing_id, request_id);
+    CancelPendingRequest(request_id);
   }
 }
 
 void ResourceDispatcher::FollowPendingRedirect(
     int request_id,
     PendingRequestInfo& request_info) {
   IPC::Message* msg = request_info.pending_redirect_message.release();
   if (msg)
     message_sender()->Send(msg);
 }
@@ skipping 51 matching lines @@
     return false;
 
   SiteIsolationPolicy::OnRequestComplete(request_id);
   PendingRequestInfo& request_info = it->second;
   ReleaseResourcesInMessageQueue(&request_info.deferred_message_queue);
   pending_requests_.erase(it);
 
   return true;
 }
 
-void ResourceDispatcher::CancelPendingRequest(int routing_id,
-                                              int request_id) {
+void ResourceDispatcher::CancelPendingRequest(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     DVLOG(1) << "unknown request";
     return;
   }
 
   SiteIsolationPolicy::OnRequestComplete(request_id);
   PendingRequestInfo& request_info = it->second;
   ReleaseResourcesInMessageQueue(&request_info.deferred_message_queue);
   pending_requests_.erase(it);
 
-  message_sender()->Send(
-      new ResourceHostMsg_CancelRequest(routing_id, request_id));
+  message_sender()->Send(new ResourceHostMsg_CancelRequest(request_id));
 }
 
 void ResourceDispatcher::SetDefersLoading(int request_id, bool value) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     DLOG(ERROR) << "unknown request";
     return;
   }
   PendingRequestInfo& request_info = it->second;
   if (value) {
     request_info.is_deferred = value;
   } else if (request_info.is_deferred) {
     request_info.is_deferred = false;
 
     FollowPendingRedirect(request_id, request_info);
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResourceDispatcher::FlushDeferredMessages,
                    weak_factory_.GetWeakPtr(),
                    request_id));
   }
 }
 
 void ResourceDispatcher::DidChangePriority(
     int routing_id, int request_id, net::RequestPriority new_priority) {
   DCHECK(ContainsKey(pending_requests_, request_id));
   message_sender()->Send(new ResourceHostMsg_DidChangePriority(
-      routing_id, request_id, new_priority));
+      request_id, new_priority));
 }
 
 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo()
     : peer(NULL),
       resource_type(ResourceType::SUB_RESOURCE),
       is_deferred(false),
       buffer_size(0) {
 }
 
 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo(
@@ skipping 170 matching lines @@
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }
 
 }  // namespace content