Get rid of RenderViewHostDelegate::Resource and dispatch the IPC messages dir...

chrome/browser/renderer_host/render_view_host_delegate.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.
 
 #ifndef CHROME_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_DELEGATE_H_
 #define CHROME_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_DELEGATE_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/process_util.h"
 #include "base/ref_counted.h"
 #include "base/string16.h"
 #include "chrome/common/content_settings_types.h"
 #include "chrome/common/dom_storage_common.h"
 #include "chrome/common/translate_errors.h"
 #include "chrome/common/view_types.h"
 #include "chrome/common/window_container_type.h"
+#include "ipc/ipc_channel.h"
 #include "net/base/load_states.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDragOperation.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPopupType.h"
 #include "webkit/glue/window_open_disposition.h"
 
 
 class AutomationResourceRoutingDelegate;
 class BackgroundContents;
 struct BookmarkNodeData;
 class BookmarkNode;
@@ skipping 56 matching lines @@
 //
 //  An interface implemented by an object interested in knowing about the state
 //  of the RenderViewHost.
 //
 //  This interface currently encompasses every type of message that was
 //  previously being sent by TabContents itself. Some of these notifications
 //  may not be relevant to all users of RenderViewHost and we should consider
 //  exposing a more generic Send function on RenderViewHost and a response
 //  listener here to serve that need.
 //
-class RenderViewHostDelegate {
+class RenderViewHostDelegate : public IPC::Channel::Listener {
  public:
   // View ----------------------------------------------------------------------
   // Functions that can be routed directly to a view-specific class.
 
   class View {
    public:
     // The page is trying to open a new page (e.g. a popup window). The
     // window should be created associated with the given route, but it should
     // not be shown yet. That should happen in response to ShowCreatedWindow.
     // |window_container_type| describes the type of RenderViewHost container
@@ skipping 207 matching lines @@
         int32 page_id,
         const std::vector<std::string>& result) = 0;
 
     // Notification of whether the page supports instant-style interaction.
     virtual void OnInstantSupportDetermined(int32 page_id, bool result) = 0;
 
    protected:
     virtual ~BrowserIntegration() {}
   };
 
-  // Resource ------------------------------------------------------------------
-  // Notifications of resource loading events.
-
-  class Resource {
-   public:
-    // The RenderView is starting a provisional load.
-    virtual void DidStartProvisionalLoadForFrame(
-        RenderViewHost* render_view_host,
-        int64 frame_id,
-        bool is_main_frame,
-        bool is_error_page,
-        const GURL& url) = 0;
-
-    // Notification by the resource loading system (not the renderer) that it
-    // has started receiving a resource response. This is different than
-    // DidStartProvisionalLoadForFrame above because this is called for every
-    // resource (images, automatically loaded subframes, etc.) and provisional
-    // loads are only for user-initiated navigations.
-    virtual void DidStartReceivingResourceResponse(
-        const ResourceRequestDetails& details) = 0;
-
-    // Sent when a provisional load is redirected.
-    virtual void DidRedirectProvisionalLoad(int32 page_id,
-                                            const GURL& source_url,
-                                            const GURL& target_url) = 0;
-
-    // Notification by the resource loading system (not the renderer) that a
-    // resource was redirected. This is different than
-    // DidRedirectProvisionalLoad above because this is called for every
-    // resource (images, automatically loaded subframes, etc.) and provisional
-    // loads are only for user-initiated navigations.
-    virtual void DidRedirectResource(
-        const ResourceRedirectDetails& details) = 0;
-
-    // The RenderView loaded a resource from an in-memory cache.
-    // |security_info| contains the security info if this resource was
-    // originally loaded over a secure connection.
-    virtual void DidLoadResourceFromMemoryCache(
-        const GURL& url,
-        const std::string& frame_origin,
-        const std::string& main_frame_origin,
-        const std::string& security_info) = 0;
-
-    virtual void DidDisplayInsecureContent() = 0;
-    virtual void DidRunInsecureContent(const std::string& security_origin) = 0;
-
-    // The RenderView failed a provisional load with an error.
-    virtual void DidFailProvisionalLoadWithError(
-        RenderViewHost* render_view_host,
-        int64 frame_id,
-        bool is_main_frame,
-        int error_code,
-        const GURL& url,
-        bool showing_repost_interstitial) = 0;
-
-    // Notification that a document has been loaded in a frame.
-    virtual void DocumentLoadedInFrame(int64 frame_id) = 0;
-
-    // Notification that a frame finished loading.
-    virtual void DidFinishLoad(int64 frame_id) = 0;
-
-   protected:
-    virtual ~Resource() {}
-  };
-
   // ContentSettings------------------------------------------------------------
   // Interface for content settings related events.
 
   class ContentSettings {
    public:
     // Called when content in the current page was blocked due to the user's
     // content settings.
     virtual void OnContentBlocked(ContentSettingsType type,
                                   const std::string& resource_identifier) = 0;
 
@@ skipping 265 matching lines @@
     virtual ~FileSelect() {}
   };
 
   // ---------------------------------------------------------------------------
 
   // Returns the current delegate associated with a feature. May return NULL if
   // there is no corresponding delegate.
   virtual View* GetViewDelegate();
   virtual RendererManagement* GetRendererManagementDelegate();
   virtual BrowserIntegration* GetBrowserIntegrationDelegate();
-  virtual Resource* GetResourceDelegate();
   virtual ContentSettings* GetContentSettingsDelegate();
   virtual Save* GetSaveDelegate();
   virtual Printing* GetPrintingDelegate();
   virtual FavIcon* GetFavIconDelegate();
   virtual Autocomplete* GetAutocompleteDelegate();
   virtual AutoFill* GetAutoFillDelegate();
   virtual BookmarkDrag* GetBookmarkDragDelegate();
   virtual SSL* GetSSLDelegate();
   virtual FileSelect* GetFileSelectDelegate();
 
   // Return the delegate for registering RenderViewHosts for automation resource
   // routing.
   virtual AutomationResourceRoutingDelegate*
       GetAutomationResourceRoutingDelegate();
 
+  // IPC::Channel::Listener implementation.
+  // This is used to give the delegate a chance to filter IPC messages.

[brettw, 2010/12/29 20:20:34]

Can you also say something like "this will get called for each IPC message
received by the RenderViewHost, and if the delegate returns true, further
processing will not occur."

[jam, 2010/12/29 21:52:47]

isn't the concept of message filtering spread all over the code?  I feel if we
explicitly say here that returning true from OnMessageHandled will mean that the
message isn't dispatched then we'll have to repeat this comment in lot of other
places, and it'll be kind of redundant

+  virtual bool OnMessageReceived(const IPC::Message& message);
+
   // Gets the URL that is currently being displayed, if there is one.
   virtual const GURL& GetURL() const;
 
   // Return this object cast to a TabContents, if it is one. If the object is
   // not a TabContents, returns NULL.
   virtual TabContents* GetAsTabContents();
 
   // Return this object cast to a BackgroundContents, if it is one. If the
   // object is not a BackgroundContents, returns NULL.
   virtual BackgroundContents* GetAsBackgroundContents();
@@ skipping 183 matching lines @@
                                 bool remember) {}
 
   // Update the content restrictions, i.e. disable print/copy.
   virtual void UpdateContentRestrictions(int restrictions) {}
 
  protected:
   virtual ~RenderViewHostDelegate() {}
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_DELEGATE_H_