Move resource related IPCs to their own file in content.

chrome/common/resource_dispatcher.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 "chrome/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
-#include "chrome/common/render_messages.h"
-#include "chrome/common/render_messages_params.h"
-#include "chrome/common/resource_response.h"
 #include "chrome/common/security_filter_peer.h"
+#include "content/common/resource_response.h"
+#include "content/common/resource_messages.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/glue/resource_type.h"
 #include "webkit/glue/webkit_glue.h"
 
 // Each resource request is assigned an ID scoped to this process.
 static int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
@@ skipping 31 matching lines @@
 
  private:
   ResourceLoaderBridge::Peer* peer_;
 
   // The resource dispatcher for this loader.  The bridge doesn't own it, but
   // it's guaranteed to outlive the bridge.
   ResourceDispatcher* dispatcher_;
 
   // The request to send, created on initialization for modification and
   // appending data.
-  ViewHostMsg_Resource_Request request_;
+  ResourceHostMsg_Request request_;
 
   // ID for the request, valid once Start()ed, -1 if not valid yet.
   int request_id_;
 
   // The routing id used when sending IPC messages.
   int routing_id_;
 
   // The following two members are specified if the request is initiated by
   // a plugin like Gears.
 
@@ skipping 35 matching lines @@
 IPCResourceLoaderBridge::~IPCResourceLoaderBridge() {
   // we remove our hook for the resource dispatcher only when going away, since
   // it doesn't keep track of whether we've force terminated the request
   if (request_id_ >= 0) {
     // this operation may fail, as the dispatcher will have preemptively
     // removed us when the renderer sends the ReceivedAllData message.
     dispatcher_->RemovePendingRequest(request_id_);
 
     if (request_.download_to_file) {
       dispatcher_->message_sender()->Send(
-          new ViewHostMsg_ReleaseDownloadedFile(request_id_));
+          new ResourceHostMsg_ReleaseDownloadedFile(request_id_));
     }
   }
 }
 
 void IPCResourceLoaderBridge::AppendDataToUpload(const char* data,
                                                  int data_len) {
   DCHECK(request_id_ == -1) << "request already started";
 
   // don't bother appending empty data segments
   if (data_len == 0)
@@ skipping 38 matching lines @@
     return false;
   }
 
   peer_ = peer;
 
   // generate the request ID, and append it to the message
   request_id_ = dispatcher_->AddPendingRequest(
       peer_, request_.resource_type, request_.url);
 
   return dispatcher_->message_sender()->Send(
-      new ViewHostMsg_RequestResource(routing_id_, request_id_, request_));
+      new ResourceHostMsg_RequestResource(routing_id_, request_id_, request_));
 }
 
 void IPCResourceLoaderBridge::Cancel() {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to cancel an unstarted request";
     return;
   }
 
   dispatcher_->CancelPendingRequest(routing_id_, request_id_);
 
@@ skipping 14 matching lines @@
 void IPCResourceLoaderBridge::SyncLoad(SyncLoadResponse* response) {
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     response->status.set_status(net::URLRequestStatus::FAILED);
     return;
   }
 
   request_id_ = MakeRequestID();
 
   SyncLoadResult result;
-  IPC::SyncMessage* msg = new ViewHostMsg_SyncLoad(routing_id_, request_id_,
-                                                   request_, &result);
+  IPC::SyncMessage* msg = new ResourceHostMsg_SyncLoad(routing_id_, request_id_,
+                                                       request_, &result);
   // NOTE: This may pump events (see RenderThread::Send).
   if (!dispatcher_->message_sender()->Send(msg)) {
     response->status.set_status(net::URLRequestStatus::FAILED);
     return;
   }
 
   response->status = result.status;
   response->url = result.final_url;
   response->headers = result.headers;
   response->mime_type = result.mime_type;
@@ skipping 78 matching lines @@
 void ResourceDispatcher::OnUploadProgress(
     const IPC::Message& message, 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 ViewHostMsg_UploadProgress_ACK(message.routing_id(), request_id));
+      new ResourceHostMsg_UploadProgress_ACK(message.routing_id(), request_id));
 }
 
 void ResourceDispatcher::OnReceivedResponse(
     int request_id, const ResourceResponseHead& response_head) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   webkit_glue::ResourceLoaderBridge::Peer* new_peer = webkit_glue::ReplacePeer(
       request_info->peer, response_head.mime_type, request_info->url);
@@ skipping 12 matching lines @@
   if (data.size())
     request_info->peer->OnReceivedCachedMetadata(&data.front(), data.size());
 }
 
 void ResourceDispatcher::OnReceivedData(const IPC::Message& message,
                                         int request_id,
                                         base::SharedMemoryHandle shm_handle,
                                         int data_len) {
   // Acknowledge the reception of this data.
   message_sender()->Send(
-      new ViewHostMsg_DataReceived_ACK(message.routing_id(), request_id));
+      new ResourceHostMsg_DataReceived_ACK(message.routing_id(), request_id));
 
   const bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle);
   DCHECK((shm_valid && data_len > 0) || (!shm_valid && !data_len));
   base::SharedMemory shared_mem(shm_handle, true);  // read only
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   if (data_len > 0 && shared_mem.Map(data_len)) {
     const char* data = static_cast<char*>(shared_mem.memory());
     request_info->peer->OnReceivedData(data, data_len);
   }
 }
 
 void ResourceDispatcher::OnDownloadedData(const IPC::Message& message,
                                           int request_id,
                                           int data_len) {
   // Acknowledge the reception of this message.
   message_sender()->Send(
-      new ViewHostMsg_DataDownloaded_ACK(message.routing_id(), request_id));
+      new ResourceHostMsg_DataDownloaded_ACK(message.routing_id(), request_id));
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   request_info->peer->OnDownloadedData(data_len);
 }
 
 void ResourceDispatcher::OnReceivedRedirect(
     const IPC::Message& message,
     int request_id,
     const GURL& new_url,
     const webkit_glue::ResourceResponseInfo& info) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   int32 routing_id = message.routing_id();
   bool has_new_first_party_for_cookies = false;
   GURL new_first_party_for_cookies;
   if (request_info->peer->OnReceivedRedirect(new_url, 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;
     request_info->pending_redirect_message.reset(
-        new ViewHostMsg_FollowRedirect(routing_id, request_id,
-                                       has_new_first_party_for_cookies,
-                                       new_first_party_for_cookies));
+        new ResourceHostMsg_FollowRedirect(routing_id, 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);
   }
 }
 
 void ResourceDispatcher::FollowPendingRedirect(
     int request_id,
@@ skipping 64 matching lines @@
   if (it == pending_requests_.end()) {
     DLOG(WARNING) << "unknown request";
     return;
   }
 
   PendingRequestInfo& request_info = it->second;
   ReleaseResourcesInMessageQueue(&request_info.deferred_message_queue);
   pending_requests_.erase(it);
 
   message_sender()->Send(
-      new ViewHostMsg_CancelRequest(routing_id, request_id));
+      new ResourceHostMsg_CancelRequest(routing_id, 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);
 
     MessageLoop::current()->PostTask(FROM_HERE,
         method_factory_.NewRunnableMethod(
             &ResourceDispatcher::FlushDeferredMessages, request_id));
   }
 }
 
 void ResourceDispatcher::DispatchMessage(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(ResourceDispatcher, message)
-    IPC_MESSAGE_HANDLER(ViewMsg_Resource_UploadProgress, OnUploadProgress)
-    IPC_MESSAGE_HANDLER(ViewMsg_Resource_ReceivedResponse, OnReceivedResponse)
-    IPC_MESSAGE_HANDLER(
-        ViewMsg_Resource_ReceivedCachedMetadata, OnReceivedCachedMetadata)
-    IPC_MESSAGE_HANDLER(ViewMsg_Resource_ReceivedRedirect, OnReceivedRedirect)
-    IPC_MESSAGE_HANDLER(ViewMsg_Resource_DataReceived, OnReceivedData)
-    IPC_MESSAGE_HANDLER(ViewMsg_Resource_DataDownloaded, OnDownloadedData)
-    IPC_MESSAGE_HANDLER(ViewMsg_Resource_RequestComplete, OnRequestComplete)
+    IPC_MESSAGE_HANDLER(ResourceMsg_UploadProgress, OnUploadProgress)
+    IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedResponse, OnReceivedResponse)
+    IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedCachedMetadata,
+                        OnReceivedCachedMetadata)
+    IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedRedirect, OnReceivedRedirect)
+    IPC_MESSAGE_HANDLER(ResourceMsg_DataReceived, OnReceivedData)
+    IPC_MESSAGE_HANDLER(ResourceMsg_DataDownloaded, OnDownloadedData)
+    IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestComplete)
   IPC_END_MESSAGE_MAP()
 }
 
 void ResourceDispatcher::FlushDeferredMessages(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())  // The request could have become invalid.
     return;
   PendingRequestInfo& request_info = it->second;
   if (request_info.is_deferred)
     return;
@@ skipping 26 matching lines @@
     int host_renderer_id,
     int host_render_view_id) {
   return new webkit_glue::IPCResourceLoaderBridge(this, request_info,
                                                   host_renderer_id,
                                                   host_render_view_id);
 }
 
 bool ResourceDispatcher::IsResourceDispatcherMessage(
     const IPC::Message& message) {
   switch (message.type()) {
-    case ViewMsg_Resource_UploadProgress::ID:
-    case ViewMsg_Resource_ReceivedResponse::ID:
-    case ViewMsg_Resource_ReceivedCachedMetadata::ID:
-    case ViewMsg_Resource_ReceivedRedirect::ID:
-    case ViewMsg_Resource_DataReceived::ID:
-    case ViewMsg_Resource_DataDownloaded::ID:
-    case ViewMsg_Resource_RequestComplete::ID:
+    case ResourceMsg_UploadProgress::ID:
+    case ResourceMsg_ReceivedResponse::ID:
+    case ResourceMsg_ReceivedCachedMetadata::ID:
+    case ResourceMsg_ReceivedRedirect::ID:
+    case ResourceMsg_DataReceived::ID:
+    case ResourceMsg_DataDownloaded::ID:
+    case ResourceMsg_RequestComplete::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }
 
 // static
 void ResourceDispatcher::ReleaseResourcesInDataMessage(
     const IPC::Message& message) {
   void* iter = NULL;
   int request_id;
   if (!message.ReadInt(&iter, &request_id)) {
     NOTREACHED() << "malformed resource message";
     return;
   }
 
   // If the message contains a shared memory handle, we should close the
   // handle or there will be a memory leak.
-  if (message.type() == ViewMsg_Resource_DataReceived::ID) {
+  if (message.type() == ResourceMsg_DataReceived::ID) {
     base::SharedMemoryHandle shm_handle;
     if (IPC::ParamTraits<base::SharedMemoryHandle>::Read(&message,
                                                          &iter,
                                                          &shm_handle)) {
       base::SharedMemory::CloseHandle(shm_handle);
     }
   }
 }
 
 // static
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }