Fix a bug where redirect chain gets lost on process swap.

content/browser/renderer_host/render_view_host_notification_task.h

 // 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.
 
 // This file defines utility functions for sending notifications (calling
 // methods that return void and do not have out params) to the RenderViewHost
 // or one of its delegate interfaces.  The notifications are dispatched
 // asynchronously, and only if the specified RenderViewHost still exists.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_NOTIFICATION_TASK_H_
@@ skipping 53 matching lines @@
                                      Method method, const Params& params) {
   using content::BrowserThread;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       new RenderViewHostNotificationTask<Method, Params>(render_process_id,
                                                          render_view_id,
                                                          method,
                                                          params));
 }
 
+class RenderViewHostToDelegate {
+ public:
+  typedef RenderViewHostDelegate MappedType;
+  static MappedType* Map(RenderViewHost* rvh) {
+    return rvh ? rvh->delegate() : NULL;
+  }
+};
+
+template <typename Method, typename Params>
+inline void CallRenderViewHostDelegateHelper(
+    int render_process_id,
+    int render_view_id,
+    Method method,
+    const Params& params) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      new RenderViewHostNotificationTask<
+          Method, Params, RenderViewHostToDelegate>(
+              render_process_id,
+              render_view_id,
+              method,
+              params));
+}

[Matt Perry, 2011/11/23 02:51:20]

this stuff is only necessary for step 1 of the hack in RDH

+
 // For proxying calls to RenderViewHostDelegate::RendererManagement
 
 class RenderViewHostToRendererManagementDelegate {
  public:
   typedef RenderViewHostDelegate::RendererManagement MappedType;
   static MappedType* Map(RenderViewHost* rvh) {
     return rvh ? rvh->delegate()->GetRendererManagementDelegate() : NULL;
   }
 };
 
@@ skipping 46 matching lines @@
                                Method method,
                                const A& a,
                                const B& b) {
   internal::CallRenderViewHostHelper(render_process_id,
                                      render_view_id,
                                      method,
                                      MakeTuple(a, b));
 }
 
 // ----------------------------------------------------------------------------
+// Proxy calls to the specified RenderViewHostDelegate.
+
+template <typename Method>
+inline void CallRenderViewHostDelegate(int render_process_id,
+                                       int render_view_id,
+                                       Method method) {
+  internal::CallRenderViewHostDelegateHelper(render_process_id,
+                                             render_view_id,
+                                             method,
+                                             MakeTuple());
+}
+
+template <typename Method, typename A>
+inline void CallRenderViewHostDelegate(int render_process_id,
+                                       int render_view_id,
+                                       Method method,
+                                       const A& a) {
+  internal::CallRenderViewHostDelegateHelper(render_process_id,
+                                             render_view_id,
+                                             method,
+                                             MakeTuple(a));
+}
+
+template <typename Method, typename A, typename B>
+inline void CallRenderViewHostDelegate(int render_process_id,
+                                       int render_view_id,
+                                       Method method,
+                                       const A& a,
+                                       const B& b) {
+  internal::CallRenderViewHostDelegateHelper(render_process_id,
+                                             render_view_id,
+                                             method,
+                                             MakeTuple(a, b));
+}
+
+template <typename Method, typename A, typename B, typename C>
+inline void CallRenderViewHostDelegate(int render_process_id,
+                                       int render_view_id,
+                                       Method method,
+                                       const A& a,
+                                       const B& b,
+                                       const C& c) {
+  internal::CallRenderViewHostDelegateHelper(render_process_id,
+                                             render_view_id,
+                                             method,
+                                             MakeTuple(a, b, c));
+}
+
+template <typename Method, typename A, typename B, typename C, typename D>
+inline void CallRenderViewHostDelegate(int render_process_id,
+                                       int render_view_id,
+                                       Method method,
+                                       const A& a,
+                                       const B& b,
+                                       const C& c,
+                                       const D& d) {
+  internal::CallRenderViewHostDelegateHelper(render_process_id,
+                                             render_view_id,
+                                             method,
+                                             MakeTuple(a, b, c, d));
+}
+// ----------------------------------------------------------------------------
 // Proxy calls to the specified RenderViewHost's RendererManagement delegate.
 
 template <typename Method>
 inline void CallRenderViewHostRendererManagementDelegate(int render_process_id,
                                                          int render_view_id,
                                                          Method method) {
   internal::CallRenderViewHostRendererManagementDelegateHelper(
       render_process_id,
       render_view_id,
       method,
@@ skipping 21 matching lines @@
   internal::CallRenderViewHostRendererManagementDelegateHelper(
       render_process_id,
       render_view_id,
       method,
       MakeTuple(a, b));
 }
 
 // ----------------------------------------------------------------------------
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_NOTIFICATION_TASK_H_