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

content/browser/loader/async_resource_handler.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/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 60 matching lines @@
       : net::WrappedIOBuffer(memory),
         backing_(backing) {
   }
  private:
   virtual ~DependentIOBuffer() {}
   scoped_refptr<ResourceBuffer> backing_;
 };
 
 AsyncResourceHandler::AsyncResourceHandler(
     ResourceMessageFilter* filter,
-    int routing_id,
     net::URLRequest* request,
     ResourceDispatcherHostImpl* rdh)
     : ResourceMessageDelegate(request),
       filter_(filter),
-      routing_id_(routing_id),
       request_(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_first_data_msg_(false) {
   InitializeResourceBufferConstants();
 }
@@ skipping 35 matching lines @@
 
     buffer_->RecycleLeastRecentlyAllocated();
     if (buffer_->CanAllocate())
       ResumeIfDeferred();
   }
 }
 
 bool AsyncResourceHandler::OnUploadProgress(int request_id,
                                             uint64 position,
                                             uint64 size) {
-  return filter_->Send(new ResourceMsg_UploadProgress(routing_id_, request_id,
-                                                      position, size));
+  return filter_->Send(new ResourceMsg_UploadProgress(request_id, position,
+                                                      size));
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(int request_id,
                                                const GURL& new_url,
                                                ResourceResponse* response,
                                                bool* defer) {
   *defer = did_defer_ = true;
 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnRequestRedirected(new_url, request_,
                                           filter_->resource_context(),
                                           response);
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
   response->head.request_start = request_->creation_time();
   response->head.response_start = TimeTicks::Now();
   return filter_->Send(new ResourceMsg_ReceivedRedirect(
-      routing_id_, request_id, new_url, response->head));
+      request_id, new_url, response->head));
 }
 
 bool AsyncResourceHandler::OnResponseStarted(int request_id,
                                              ResourceResponse* response,
                                              bool* defer) {
   // For changes to the main frame, inform the renderer of the new URL's
   // per-host settings before the request actually commits.  This way the
   // renderer will be able to set these precisely at the time the
   // request commits, avoiding the possibility of e.g. zooming the old content
   // or of having to layout the new content twice.
@@ skipping 14 matching lines @@
     const GURL& request_url = request_->url();
     filter_->Send(new ViewMsg_SetZoomLevelForLoadingURL(
         info->GetRouteID(),
         request_url, host_zoom_map->GetZoomLevelForHostAndScheme(
             request_url.scheme(),
             net::GetHostOrSpecFromURL(request_url))));
   }
 
   response->head.request_start = request_->creation_time();
   response->head.response_start = TimeTicks::Now();
-  filter_->Send(new ResourceMsg_ReceivedResponse(
-      routing_id_, request_id, response->head));
+  filter_->Send(new ResourceMsg_ReceivedResponse(request_id, response->head));
   sent_received_response_msg_ = true;
 
   if (request_->response_info().metadata.get()) {
     std::vector<char> copy(request_->response_info().metadata->data(),
                            request_->response_info().metadata->data() +
                                request_->response_info().metadata->size());
-    filter_->Send(new ResourceMsg_ReceivedCachedMetadata(
-        routing_id_, request_id, copy));
+    filter_->Send(new ResourceMsg_ReceivedCachedMetadata(request_id, copy));
   }
 
   return true;
 }
 
 bool AsyncResourceHandler::OnWillStart(int request_id,
                                        const GURL& url,
                                        bool* defer) {
   return true;
 }
@@ skipping 30 matching lines @@
       bytes_read, 0, kMaxAllocationSize, 100);
   UMA_HISTOGRAM_PERCENTAGE(
       "Net.AsyncResourceHandler_SharedIOBuffer_UsedPercentage",
       CalcUsedPercentage(bytes_read, allocation_size_));
 
   if (!sent_first_data_msg_) {
     base::SharedMemoryHandle handle;
     int size;
     if (!buffer_->ShareToProcess(filter_->PeerHandle(), &handle, &size))
       return false;
-    filter_->Send(
-        new ResourceMsg_SetDataBuffer(routing_id_, request_id, handle, size,
-                                      filter_->peer_pid()));
+    filter_->Send(new ResourceMsg_SetDataBuffer(
+        request_id, handle, size, filter_->peer_pid()));
     sent_first_data_msg_ = true;
   }
 
   int data_offset = buffer_->GetLastAllocationOffset();
   int encoded_data_length =
       DevToolsNetLogObserver::GetAndResetEncodedDataLength(request_);
 
-  filter_->Send(
-      new ResourceMsg_DataReceived(routing_id_, request_id, data_offset,
-                                   bytes_read, encoded_data_length));
+  filter_->Send(new ResourceMsg_DataReceived(
+      request_id, data_offset, bytes_read, encoded_data_length));
   ++pending_data_count_;
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Net.AsyncResourceHandler_PendingDataCount",
       pending_data_count_, 0, 100, 100);
 
   if (!buffer_->CanAllocate()) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.AsyncResourceHandler_PendingDataCount_WhenFull",
         pending_data_count_, 0, 100, 100);
     *defer = did_defer_ = true;
   }
 
   return true;
 }
 
 void AsyncResourceHandler::OnDataDownloaded(
     int request_id, int bytes_downloaded) {
   int encoded_data_length =
       DevToolsNetLogObserver::GetAndResetEncodedDataLength(request_);
 
   filter_->Send(new ResourceMsg_DataDownloaded(
-      routing_id_, request_id, bytes_downloaded, encoded_data_length));
+      request_id, bytes_downloaded, encoded_data_length));
 }
 
 bool AsyncResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/107692
   char url_buf[128];
   base::strlcpy(url_buf, request_->url().spec().c_str(), arraysize(url_buf));
@@ skipping 22 matching lines @@
   // TODO(mkosiba): Fix up cases where we create a URLRequestStatus
   // with a status() != SUCCESS and an error_code() == net::OK.
   if (status.status() == net::URLRequestStatus::CANCELED &&
       error_code == net::OK) {
     error_code = net::ERR_ABORTED;
   } else if (status.status() == net::URLRequestStatus::FAILED &&
              error_code == net::OK) {
     error_code = net::ERR_FAILED;
   }
 
-  filter_->Send(new ResourceMsg_RequestComplete(routing_id_,
-                                                request_id,
+  filter_->Send(new ResourceMsg_RequestComplete(request_id,
                                                 error_code,
                                                 was_ignored_by_handler,
                                                 security_info,
                                                 completion_time));
   return true;
 }
 
 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() {
   if (buffer_.get() && buffer_->IsInitialized())
     return true;
@@ skipping 13 matching lines @@
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content