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

chrome/browser/renderer_host/resource_dispatcher_host.h

 // 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.
 
 // This is the browser side of the resource dispatcher, it receives requests
 // from the child process (i.e. [Renderer, Plugin, Worker]ProcessHost), and
 // dispatches them to URLRequests. It then forwards the messages from the
 // URLRequests back to the correct process for handling.
 //
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
@@ skipping 17 matching lines @@
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_type.h"
 
 class CrossSiteResourceHandler;
 class DownloadFileManager;
 class DownloadRequestLimiter;
 class LoginHandler;
 class PluginService;
 class ResourceDispatcherHostRequestInfo;
 class ResourceHandler;
+class ResourceMessageFilter;
 class SafeBrowsingService;
 class SaveFileManager;
 class SSLClientAuthHandler;
 class UserScriptListener;
 class URLRequestContext;
 class WebKitThread;
 struct DownloadSaveInfo;
 struct GlobalRequestID;
 struct ViewHostMsg_Resource_Request;
 struct ViewMsg_ClosePage_Params;
 
 namespace webkit_blob {
 class DeletableFileReference;
 }
 
 class ResourceDispatcherHost : public net::URLRequest::Delegate {
  public:
-  // Implemented by the client of ResourceDispatcherHost to receive messages in
-  // response to a resource load.  The messages are intended to be forwarded to
-  // the ResourceDispatcher in the child process via an IPC channel that the
-  // client manages.
-  //
-  // NOTE: This class unfortunately cannot be named 'Delegate' because that
-  // conflicts with the name of ResourceDispatcherHost's base class.
-  //
-  // If the receiver is unable to send a given message (i.e., if Send returns
-  // false), then the ResourceDispatcherHost assumes the receiver has failed,
-  // and the given request will be dropped. (This happens, for example, when a
-  // renderer crashes and the channel dies).
-  class Receiver : public IPC::Message::Sender,
-                   public ChildProcessInfo {
-   public:
-    // Returns the URLRequestContext for the given request.
-    // If NULL is returned, the default context for the profile is used.
-    virtual URLRequestContext* GetRequestContext(
-        uint32 request_id,
-        const ViewHostMsg_Resource_Request& request_data) = 0;
-
-   protected:
-    explicit Receiver(ChildProcessInfo::ProcessType type, int child_id);
-    virtual ~Receiver();
-  };
-
   class Observer {
    public:
     virtual ~Observer() {}
     virtual void OnRequestStarted(ResourceDispatcherHost* resource_dispatcher,
                                   net::URLRequest* request) = 0;
     virtual void OnResponseCompleted(
         ResourceDispatcherHost* resource_dispatcher,
         net::URLRequest* request) = 0;
     virtual void OnReceivedRedirect(ResourceDispatcherHost* resource_dispatcher,
                                     net::URLRequest* request,
                                     const GURL& new_url) = 0;
   };
 
   ResourceDispatcherHost();
   ~ResourceDispatcherHost();
 
   void Initialize();
 
   // Puts the resource dispatcher host in an inactive state (unable to begin
   // new requests).  Cancels all pending requests.
   void Shutdown();
 
   // Returns true if the message was a resource message that was processed.
   // If it was, message_was_ok will be false iff the message was corrupt.
   bool OnMessageReceived(const IPC::Message& message,
-                         Receiver* receiver,
+                         ResourceMessageFilter* filter,
                          bool* message_was_ok);
 
   // Initiates a download from the browser process (as opposed to a resource
   // request from the renderer or another child process).
   void BeginDownload(const GURL& url,
                      const GURL& referrer,
                      const DownloadSaveInfo& save_info,
                      bool prompt_for_save_location,
                      int process_unique_id,
                      int route_id,
@@ skipping 152 matching lines @@
   // Decrements the pending_data_count for the request and resumes
   // the request if it was paused due to too many pending data
   // messages sent.
   void DataReceivedACK(int process_unique_id, int request_id);
 
   // Maintains a collection of temp files created in support of
   // the download_to_file capability. Used to grant access to the
   // child process and to defer deletion of the file until it's
   // no longer needed.
   void RegisterDownloadedTempFile(
-      int receiver_id, int request_id,
+      int child_id, int request_id,
       webkit_blob::DeletableFileReference* reference);
-  void UnregisterDownloadedTempFile(int receiver_id, int request_id);
+  void UnregisterDownloadedTempFile(int child_id, int request_id);
 
   // Needed for the sync IPC message dispatcher macros.
   bool Send(IPC::Message* message);
 
   // Controls if we launch or squash prefetch requests as they arrive
   // from renderers.
   static bool is_prefetch_enabled();
   static void set_is_prefetch_enabled(bool value);
 
  private:
@@ skipping 123 matching lines @@
   void OnDataReceivedACK(int request_id);
   void OnDataDownloadedACK(int request_id);
   void OnUploadProgressACK(int request_id);
   void OnCancelRequest(int request_id);
   void OnFollowRedirect(int request_id,
                         bool has_new_first_party_for_cookies,
                         const GURL& new_first_party_for_cookies);
   void OnReleaseDownloadedFile(int request_id);
 
   ResourceHandler* CreateSafeBrowsingResourceHandler(
-      ResourceHandler* handler, int child_id, int route_id,
-      ResourceType::Type resource_type);
+      ResourceHandler* handler, int route_id, ResourceType::Type resource_type);
 
   // Creates ResourceDispatcherHostRequestInfo for a browser-initiated request
   // (a download or a page save). |download| should be true if the request
   // is a file download.
   ResourceDispatcherHostRequestInfo* CreateRequestInfoForBrowserRequest(
       ResourceHandler* handler, int child_id, int route_id, bool download);
 
   // Returns true if |request| is in |pending_requests_|.
   bool IsValidRequest(net::URLRequest* request);
 
-  // Returns true if the message passed in is a resource related message.
-  static bool IsResourceDispatcherHostMessage(const IPC::Message&);
-
   // Sets replace_extension_localization_templates on all text/css requests that
   // have "chrome-extension://" scheme.
   static void ApplyExtensionLocalizationFilter(
       const GURL& url,
       const ResourceType::Type& resource_type,
       ResourceDispatcherHostRequestInfo* request_info);
 
   // Determine request priority based on how critical this resource typically
   // is to user-perceived page load performance.
   static net::RequestPriority DetermineRequestPriority(ResourceType::Type type);
@@ skipping 64 matching lines @@
   // many outstanding requests can be issued per child process host.
   // The constraint is expressed in terms of bytes (where the cost of
   // individual requests is given by CalculateApproximateMemoryCost).
   // The total number of outstanding requests is roughly:
   //   (max_outstanding_requests_cost_per_process_ /
   //       kAvgBytesPerOutstandingRequest)
   int max_outstanding_requests_cost_per_process_;
 
   // Used during IPC message dispatching so that the handlers can get a pointer
   // to the source of the message.
-  Receiver* receiver_;
+  ResourceMessageFilter* filter_;
 
   static bool is_prefetch_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_