Move resource related IPCs to their own file in content.

content/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2011 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/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 43 matching lines @@
 #include "content/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_notification_task.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/browser/renderer_host/resource_queue.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #include "content/browser/renderer_host/sync_resource_handler.h"
 #include "content/browser/worker_host/worker_service.h"
+#include "content/common/resource_messages.h"
 #include "net/base/auth.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
@@ skipping 45 matching lines @@
 // See delcaration of |max_outstanding_requests_cost_per_process_| for details.
 // This bound is 25MB, which allows for around 6000 outstanding requests.
 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 
 // Consults the RendererSecurity policy to determine whether the
 // ResourceDispatcherHost should service this request.  A request might be
 // disallowed if the renderer is not authorized to retrieve the request URL or
 // if the renderer is attempting to upload an unauthorized file.
 bool ShouldServiceRequest(ChildProcessInfo::ProcessType process_type,
                           int child_id,
-                          const ViewHostMsg_Resource_Request& request_data)  {
+                          const ResourceHostMsg_Request& request_data)  {
   if (process_type == ChildProcessInfo::PLUGIN_PROCESS)
     return true;
 
   if (request_data.resource_type == ResourceType::PREFETCH) {
     prerender::PrerenderManager::RecordPrefetchTagObserved();
     if (!ResourceDispatcherHost::is_prefetch_enabled())
       return false;
   }
 
   ChildProcessSecurityPolicy* policy =
@@ skipping 165 matching lines @@
       std::string());  // No security info necessary.
   return true;
 }
 
 bool ResourceDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                ResourceMessageFilter* filter,
                                                bool* message_was_ok) {
   filter_ = filter;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(ResourceDispatcherHost, message, *message_was_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_RequestResource, OnRequestResource)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_SyncLoad, OnSyncLoad)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_ReleaseDownloadedFile,
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(ResourceHostMsg_SyncLoad, OnSyncLoad)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_ReleaseDownloadedFile,
                         OnReleaseDownloadedFile)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DataReceived_ACK, OnDataReceivedACK)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DataDownloaded_ACK, OnDataDownloadedACK)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_UploadProgress_ACK, OnUploadProgressACK)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_CancelRequest, OnCancelRequest)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_FollowRedirect, OnFollowRedirect)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_DataReceived_ACK, OnDataReceivedACK)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_DataDownloaded_ACK, OnDataDownloadedACK)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_UploadProgress_ACK, OnUploadProgressACK)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_CancelRequest, OnCancelRequest)
+    IPC_MESSAGE_HANDLER(ResourceHostMsg_FollowRedirect, OnFollowRedirect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ClosePage_ACK, OnClosePageACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   filter_ = NULL;
   return handled;
 }
 
 void ResourceDispatcherHost::OnRequestResource(
     const IPC::Message& message,
     int request_id,
-    const ViewHostMsg_Resource_Request& request_data) {
+    const ResourceHostMsg_Request& request_data) {
   BeginRequest(request_id, request_data, NULL, message.routing_id());
 }
 
 // Begins a resource request with the given params on behalf of the specified
 // child process.  Responses will be dispatched through the given receiver. The
 // process ID is used to lookup TabContents from routing_id's in the case of a
 // request from a renderer.  request_context is the cookie/cache context to be
 // used for this request.
 //
 // If sync_result is non-null, then a SyncLoad reply will be generated, else
 // a normal asynchronous set of response messages will be generated.
 void ResourceDispatcherHost::OnSyncLoad(
     int request_id,
-    const ViewHostMsg_Resource_Request& request_data,
+    const ResourceHostMsg_Request& request_data,
     IPC::Message* sync_result) {
   BeginRequest(request_id, request_data, sync_result,
                sync_result->routing_id());
 }
 
 void ResourceDispatcherHost::BeginRequest(
     int request_id,
-    const ViewHostMsg_Resource_Request& request_data,
+    const ResourceHostMsg_Request& request_data,
     IPC::Message* sync_result,  // only valid for sync
     int route_id) {
   ChildProcessInfo::ProcessType process_type = filter_->process_type();
   int child_id = filter_->child_id();
 
   ChromeURLRequestContext* context = filter_->GetURLRequestContext(
       request_data);
 
   // Might need to resolve the blob references in the upload data.
   if (request_data.upload_data && context) {
     context->blob_storage_context()->controller()->
         ResolveBlobReferencesInUploadData(request_data.upload_data.get());
   }
 
   if (is_shutdown_ ||
       !ShouldServiceRequest(process_type, child_id, request_data)) {
     net::URLRequestStatus status(net::URLRequestStatus::FAILED,
                                  net::ERR_ABORTED);
     if (sync_result) {
       SyncLoadResult result;
       result.status = status;
-      ViewHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
+      ResourceHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
       filter_->Send(sync_result);
     } else {
       // Tell the renderer that this request was disallowed.
-      filter_->Send(new ViewMsg_Resource_RequestComplete(
+      filter_->Send(new ResourceMsg_RequestComplete(
           route_id,
           request_id,
           status,
           std::string(),   // No security info needed, connection was not
           base::Time()));  // established.
     }
     return;
   }
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
@@ skipping 1532 matching lines @@
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;