Support window.opener after a process swap.

content/browser/tab_contents/render_view_host_manager.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.
 
 #ifndef CONTENT_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 #define CONTENT_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
+#include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
+#include "content/browser/site_instance.h"
 
 class WebUI;
 class InterstitialPage;
 class NavigationController;
 class NavigationEntry;
 class Profile;
 class RenderWidgetHostView;
 class RenderViewHost;
-class SiteInstance;
 
 // Manages RenderViewHosts for a TabContents. Normally there is only one and
 // it is easy to do. But we can also have transitions of processes (and hence
 // RenderViewHosts) that can get complex.
 class RenderViewHostManager
-    : public RenderViewHostDelegate::RendererManagement {
+    : public RenderViewHostDelegate::RendererManagement,
+      public NotificationObserver {
  public:
   // Functions implemented by our owner that we need.
   //
   // TODO(brettw) Clean this up! These are all the functions in TabContents that
   // are required to run this class. The design should probably be better such
   // that these are more clear.
   //
   // There is additional complexity that some of the functions we need in
   // TabContents are inherited and non-virtual. These are named with
   // "RenderManager" so that the duplicate implementation of them will be clear.
@@ skipping 125 matching lines @@
   InterstitialPage* interstitial_page() const {
     return interstitial_page_;
   }
 
   // RenderViewHostDelegate::RendererManagement implementation.
   virtual void ShouldClosePage(bool for_cross_site_transition, bool proceed);
   virtual void OnCrossSiteResponse(int new_render_process_host_id,
                                    int new_request_id);
   virtual void OnCrossSiteNavigationCanceled();
 
+  // NotificationObserver implementation.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
   // Called when a RenderViewHost is about to be deleted.
   void RenderViewDeleted(RenderViewHost* rvh);
 
   // Allows a caller to swap in a provided RenderViewHost to replace the
   // current RenderViewHost.  The current RVH will be shutdown and ultimately
   // deleted.
   void SwapInRenderViewHost(RenderViewHost* rvh);
 
+  // Returns whether the given RenderViewHost is on the list of swapped out
+  // RenderViewHosts.
+  bool IsSwappedOut(RenderViewHost* rvh);
+
  private:
   friend class TestTabContents;
   friend class RenderViewHostManagerTest;
 
   // Returns whether this tab should transition to a new renderer for
   // cross-site URLs.  Enabled unless we see the --process-per-tab command line
   // switch.  Can be overridden in unit tests.
   bool ShouldTransitionCrossSite();
 
   // Returns true if the two navigation entries are incompatible in some way
@@ skipping 25 matching lines @@
   // Sets the pending RenderViewHost/WebUI to be the active one. Note that this
   // doesn't require the pending render_view_host_ pointer to be non-NULL, since
   // there could be Web UI switching as well. Call this for every commit.
   void CommitPending();
 
   // Helper method to terminate the pending RenderViewHost.
   void CancelPending();
 
   RenderViewHost* UpdateRendererStateForNavigate(const NavigationEntry& entry);
 
+  // Called when a renderer process is starting to close.  We should not
+  // schedule new navigations in its swapped out RenderViewHosts after this.
+  void RendererProcessClosing(RenderProcessHost* render_process_host);
+
   // Our delegate, not owned by us. Guaranteed non-NULL.
   Delegate* delegate_;
 
   // Whether a navigation requiring different RenderView's is pending. This is
   // either cross-site request is (in the new process model), or when required
   // for the view type (like view source versus not).
   bool cross_navigation_pending_;
 
   // Implemented by the owner of this class, this delegate is installed into all
   // the RenderViewHosts that we create.
@@ skipping 10 matching lines @@
   // have an associated Web UI, in which case the Web UI pointer will be non-
   // NULL.
   //
   // The pending_web_ui may be non-NULL even when the pending_render_view_host_
   // is. This will happen when we're transitioning between two Web UI pages:
   // the RVH won't be swapped, so the pending pointer will be unused, but there
   // will be a pending Web UI associated with the navigation.
   RenderViewHost* pending_render_view_host_;
   scoped_ptr<WebUI> pending_web_ui_;
 
+  // A map of site instance ID to swapped out RenderViewHosts.
+  typedef base::hash_map<int32, RenderViewHost*> RenderViewHostMap;
+  RenderViewHostMap swapped_out_hosts_;
+
   // The intersitial page currently shown if any, not own by this class
   // (the InterstitialPage is self-owned, it deletes itself when hidden).
   InterstitialPage* interstitial_page_;
 
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostManager);
 };
 
 // The "details" for a NOTIFY_RENDER_VIEW_HOST_CHANGED notification. The old
 // host can be NULL when the first RenderViewHost is set.
 struct RenderViewHostSwitchedDetails {
   RenderViewHost* old_host;
   RenderViewHost* new_host;
 };
 
 #endif  // CONTENT_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_