Create a ResourceMessageFilter to filter resource related IPCs. This gets ri...

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2010 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/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 23 matching lines @@
 #include "chrome/browser/renderer_host/async_resource_handler.h"
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
 #include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/renderer_host/render_view_host_notification_task.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
+#include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/browser/renderer_host/resource_queue.h"
 #include "chrome/browser/renderer_host/resource_request_details.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 #include "chrome/browser/renderer_host/save_file_resource_handler.h"
 #include "chrome/browser/renderer_host/sync_resource_handler.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ssl/ssl_client_auth_handler.h"
 #include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/worker_host/worker_service.h"
@@ skipping 133 matching lines @@
 std::vector<int> GetAllNetErrorCodes() {
   std::vector<int> all_error_codes;
 #define NET_ERROR(label, value) all_error_codes.push_back(-(value));
 #include "net/base/net_error_list.h"
 #undef NET_ERROR
   return all_error_codes;
 }
 
 }  // namespace
 
-ResourceDispatcherHost::Receiver::Receiver(ChildProcessInfo::ProcessType type,
-                                           int child_id)
-    : ChildProcessInfo(type, child_id) {
-}
-
-ResourceDispatcherHost::Receiver::~Receiver() {
-}
-
 ResourceDispatcherHost::ResourceDispatcherHost()
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           download_file_manager_(new DownloadFileManager(this))),
       download_request_limiter_(new DownloadRequestLimiter()),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           save_file_manager_(new SaveFileManager(this))),
       user_script_listener_(new UserScriptListener(&resource_queue_)),
       safe_browsing_(SafeBrowsingService::CreateSafeBrowsingService()),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
-      receiver_(NULL) {
+      filter_(NULL) {
   ResourceQueue::DelegateSet resource_queue_delegates;
   resource_queue_delegates.insert(user_script_listener_.get());
   resource_queue_.Initialize(resource_queue_delegates);
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 
   user_script_listener_->ShutdownMainThread();
@@ skipping 62 matching lines @@
           &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
 
   handler->OnResponseCompleted(request_id, URLRequestStatus(
                                                URLRequestStatus::FAILED,
                                                net::ERR_ABORTED),
                                std::string());  // No security info necessary.
   return true;
 }
 
 bool ResourceDispatcherHost::OnMessageReceived(const IPC::Message& message,
-                                               Receiver* receiver,
+                                               ResourceMessageFilter* filter,
                                                bool* message_was_ok) {
-  if (!IsResourceDispatcherHostMessage(message)) {
-    return false;
-  }
-
-  *message_was_ok = true;
-  receiver_ = receiver;
-
+  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,
                         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(ViewHostMsg_ClosePage_ACK, OnClosePageACK)
+    IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
-  receiver_ = NULL;
-
-  return true;
+  filter_ = NULL;
+  return handled;
 }
 
 void ResourceDispatcherHost::OnRequestResource(
     const IPC::Message& message,
     int request_id,
     const ViewHostMsg_Resource_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
@@ skipping 10 matching lines @@
     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,
     IPC::Message* sync_result,  // only valid for sync
     int route_id) {
-  ChildProcessInfo::ProcessType process_type = receiver_->type();
-  int child_id = receiver_->id();
-  ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>(
-      receiver_->GetRequestContext(request_id, request_data));
-  if (!context) {
-    URLRequestContextGetter* context_getter =
-        Profile::GetDefaultRequestContext();
-    if (context_getter) {
-      context = static_cast<ChromeURLRequestContext*>(
-          context_getter->GetURLRequestContext());
-    }
-  }
+  ChildProcessInfo::ProcessType process_type = filter_->process_type();
+  int child_id = filter_->child_id();
+
+  ChromeURLRequestContext* context = filter_->GetURLRequestContext(
+      request_id, request_data.resource_type);
 
   // 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)) {
     URLRequestStatus status(URLRequestStatus::FAILED, net::ERR_ABORTED);
     if (sync_result) {
       SyncLoadResult result;
       result.status = status;
       ViewHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
-      receiver_->Send(sync_result);
+      filter_->Send(sync_result);
     } else {
       // Tell the renderer that this request was disallowed.
-      receiver_->Send(new ViewMsg_Resource_RequestComplete(
+      filter_->Send(new ViewMsg_Resource_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
   // requests.  Does nothing if they are already loaded.
   // TODO(mpcomplete): This takes 200 ms!  Investigate parallelizing this by
   // starting the load earlier in a BG thread.
   PluginService::GetInstance()->LoadChromePlugins(this);
 
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
-    handler = new SyncResourceHandler(receiver_,
-                                      child_id,
-                                      request_data.url,
-                                      sync_result,
-                                      this);
+    handler = new SyncResourceHandler(
+        filter_, request_data.url, sync_result, this);
   } else {
-    handler = new AsyncResourceHandler(receiver_,
-                                       child_id,
-                                       route_id,
-                                       receiver_->handle(),
-                                       request_data.url,
-                                       this);
+    handler = new AsyncResourceHandler(
+        filter_, route_id, request_data.url, this);
   }
 
   // The RedirectToFileResourceHandler depends on being next in the chain.
   if (request_data.download_to_file)
     handler = new RedirectToFileResourceHandler(handler, child_id, this);
 
   if (HandleExternalProtocol(request_id, child_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
@@ skipping 57 matching lines @@
                                            route_id,
                                            this);
   }
 
   // Insert a buffered event handler before the actual one.
   handler = new BufferedResourceHandler(handler, this, request);
 
   // Insert safe browsing at the front of the chain, so it gets to decide
   // on policies first.
   if (safe_browsing_->enabled()) {
-    handler = CreateSafeBrowsingResourceHandler(handler, child_id, route_id,
+    handler = CreateSafeBrowsingResourceHandler(handler, route_id,
                                                 request_data.resource_type);
   }
 
 #if defined(OS_CHROMEOS)
   // We check offline first, then check safe browsing so that we still can block
   // unsafe site after we remove offline page.
   handler =
       new OfflineResourceHandler(handler, child_id, route_id, this, request);
 #endif
 
@@ skipping 32 matching lines @@
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
       request, context ? context->appcache_service() : NULL, child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::OnReleaseDownloadedFile(int request_id) {
   DCHECK(pending_requests_.end() ==
-         pending_requests_.find(GlobalRequestID(receiver_->id(), request_id)));
-  UnregisterDownloadedTempFile(receiver_->id(), request_id);
+         pending_requests_.find(
+             GlobalRequestID(filter_->child_id(), request_id)));
+  UnregisterDownloadedTempFile(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHost::OnDataReceivedACK(int request_id) {
-  DataReceivedACK(receiver_->id(), request_id);
+  DataReceivedACK(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHost::DataReceivedACK(int child_id,
                                              int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end())
     return;
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
@@ skipping 10 matching lines @@
     // Resume the request.
     PauseRequest(child_id, request_id, false);
   }
 }
 
 void ResourceDispatcherHost::OnDataDownloadedACK(int request_id) {
   // TODO(michaeln): maybe throttle DataDownloaded messages
 }
 
 void ResourceDispatcherHost::RegisterDownloadedTempFile(
-    int receiver_id, int request_id, DeletableFileReference* reference) {
-  // Note: receiver_id is the child_id is the render_process_id...
-  registered_temp_files_[receiver_id][request_id] = reference;
+    int child_id, int request_id, DeletableFileReference* reference) {
+  registered_temp_files_[child_id][request_id] = reference;
   ChildProcessSecurityPolicy::GetInstance()->GrantReadFile(
-      receiver_id, reference->path());
+      child_id, reference->path());
 }
 
 void ResourceDispatcherHost::UnregisterDownloadedTempFile(
-    int receiver_id, int request_id) {
-  DeletableFilesMap& map = registered_temp_files_[receiver_id];
+    int child_id, int request_id) {
+  DeletableFilesMap& map = registered_temp_files_[child_id];
   DeletableFilesMap::iterator found = map.find(request_id);
   if (found == map.end())
     return;
 
   ChildProcessSecurityPolicy::GetInstance()->RevokeAllPermissionsForFile(
-      receiver_id, found->second->path());
+      child_id, found->second->path());
   map.erase(found);
 }
 
 bool ResourceDispatcherHost::Send(IPC::Message* message) {
   delete message;
   return false;
 }
 
 void ResourceDispatcherHost::OnUploadProgressACK(int request_id) {
-  int child_id = receiver_->id();
+  int child_id = filter_->child_id();
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end())
     return;
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
   info->set_waiting_for_upload_progress_ack(false);
 }
 
 void ResourceDispatcherHost::OnCancelRequest(int request_id) {
-  CancelRequest(receiver_->id(), request_id, true);
+  CancelRequest(filter_->child_id(), request_id, true);
 }
 
 void ResourceDispatcherHost::OnFollowRedirect(
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
-  FollowDeferredRedirect(receiver_->id(), request_id,
+  FollowDeferredRedirect(filter_->child_id(), request_id,
                          has_new_first_party_for_cookies,
                          new_first_party_for_cookies);
 }
 
 ResourceHandler* ResourceDispatcherHost::CreateSafeBrowsingResourceHandler(
-    ResourceHandler* handler, int child_id, int route_id,
-    ResourceType::Type resource_type) {
-  return new SafeBrowsingResourceHandler(handler,
-                                         child_id,
-                                         route_id,
-                                         resource_type,
-                                         safe_browsing_,
-                                         this,
-                                         receiver_);
+    ResourceHandler* handler, int route_id, ResourceType::Type resource_type) {
+  return new SafeBrowsingResourceHandler(
+      handler, route_id, resource_type, safe_browsing_, this, filter_);
 }
 
 ResourceDispatcherHostRequestInfo*
 ResourceDispatcherHost::CreateRequestInfoForBrowserRequest(
     ResourceHandler* handler, int child_id, int route_id, bool download) {
   return new ResourceDispatcherHostRequestInfo(handler,
                                                ChildProcessInfo::RENDER_PROCESS,
                                                child_id,
                                                route_id,
                                                request_id_,
@@ skipping 64 matching lines @@
                                   child_id,
                                   route_id,
                                   request_id_,
                                   url,
                                   download_file_manager_.get(),
                                   request,
                                   prompt_for_save_location,
                                   save_info));
 
   if (safe_browsing_->enabled()) {
-    handler = CreateSafeBrowsingResourceHandler(handler, child_id, route_id,
+    handler = CreateSafeBrowsingResourceHandler(handler, route_id,
                                                 ResourceType::MAIN_FRAME);
   }
 
   if (!net::URLRequest::IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     return;
   }
 
   request->set_method("GET");
@@ skipping 1123 matching lines @@
 bool ResourceDispatcherHost::IsValidRequest(net::URLRequest* request) {
   if (!request)
     return false;
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   return pending_requests_.find(
       GlobalRequestID(info->child_id(), info->request_id())) !=
       pending_requests_.end();
 }
 
 // static
-bool ResourceDispatcherHost::IsResourceDispatcherHostMessage(
-    const IPC::Message& message) {
-  switch (message.type()) {
-    case ViewHostMsg_RequestResource::ID:
-    case ViewHostMsg_CancelRequest::ID:
-    case ViewHostMsg_FollowRedirect::ID:
-    case ViewHostMsg_ClosePage_ACK::ID:
-    case ViewHostMsg_ReleaseDownloadedFile::ID:
-    case ViewHostMsg_DataReceived_ACK::ID:
-    case ViewHostMsg_DataDownloaded_ACK::ID:
-    case ViewHostMsg_UploadProgress_ACK::ID:
-    case ViewHostMsg_SyncLoad::ID:
-      return true;
-
-    default:
-      break;
-  }
-
-  return false;
-}
-
-// static
 void ResourceDispatcherHost::ApplyExtensionLocalizationFilter(
     const GURL& url,
     const ResourceType::Type& resource_type,
     ResourceDispatcherHostRequestInfo* request_info) {
   // Apply filter to chrome extension CSS files.
   if (url.SchemeIs(chrome::kExtensionScheme) &&
       resource_type == ResourceType::STYLESHEET)
     request_info->set_replace_extension_localization_templates();
 }
 
@@ skipping 56 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;