Switch RenderFrameHostManager to use RenderProcessHostObserver, remove NOTIFICATION_RENDERER_PROCES…

content/browser/frame_host/render_frame_host_manager.h

 // Copyright 2013 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_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_
 
 #include <list>
+#include <map>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/global_request_id.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "content/public/common/referrer.h"
 #include "ui/base/page_transition_types.h"
 #include "url/deprecated_serialized_origin.h"
 
 namespace content {
 class BrowserContext;
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class FrameNavigationEntry;
 class FrameTreeNode;
@@ skipping 57 matching lines @@
 // - Otherwise, the network response commits in the pending RFH's renderer,
 //   which sends a DidCommitProvisionalLoad message back to the browser process.
 //
 // - RFHM::CommitPending makes visible the new RFH, and initiates the unload
 //   handler in the old RFH. The unload handler will complete in the background.
 //
 // - RenderFrameHostManager may keep the previous RFH alive as a
 //   RenderFrameProxyHost, to be used (for example) if the user goes back. The
 //   process only stays live if another tab is using it, but if so, the existing
 //   frame relationships will be maintained.
-class CONTENT_EXPORT RenderFrameHostManager : public NotificationObserver {
+class CONTENT_EXPORT RenderFrameHostManager {
  public:
   // Functions implemented by our owner that we need.
   //
   // TODO(brettw) Clean this up! These are all the functions in WebContentsImpl
   // 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
   // WebContentsImpl are inherited and non-virtual. These are named with
   // "RenderManager" so that the duplicate implementation of them will be clear.
@@ skipping 84 matching lines @@
   // mode entirely. In code that deals with the swapped out state, prefer calls
   // to this function over consulting the switches directly. It will be easier
   // to grep, and easier to rip out.
   //
   // TODO(nasko): When swappedout:// is eliminated entirely, this function (and
   // its equivalent in RenderFrameProxy) should be removed and its callers
   // cleaned up.
   static bool IsSwappedOutStateForbidden();
 
   // All three delegate pointers must be non-NULL and are not owned by this
-  // class.  They must outlive this class. The RenderViewHostDelegate and
+  // class. They must outlive this class. The RenderViewHostDelegate and
   // RenderWidgetHostDelegate are what will be installed into all
   // RenderViewHosts that are created.
   //
   // You must call Init() before using this class.
   RenderFrameHostManager(
       FrameTreeNode* frame_tree_node,
       RenderFrameHostDelegate* render_frame_delegate,
       RenderViewHostDelegate* render_view_delegate,
       RenderWidgetHostDelegate* render_widget_delegate,
       Delegate* delegate);
-  ~RenderFrameHostManager() override;
+  ~RenderFrameHostManager();
 
   // For arguments, see WebContentsImpl constructor.
   void Init(BrowserContext* browser_context,
             SiteInstance* site_instance,
             int view_routing_id,
             int frame_routing_id);
 
   // Returns the currently active RenderFrameHost.
   //
   // This will be non-NULL between Init() and Shutdown(). You may want to NULL
@@ skipping 157 matching lines @@
   // Unsets the currently showing interstitial.
   void remove_interstitial_page() {
     DCHECK(interstitial_page_);
     interstitial_page_ = NULL;
   }
 
   // Returns the currently showing interstitial, NULL if no interstitial is
   // showing.
   InterstitialPageImpl* interstitial_page() const { return interstitial_page_; }
 
-  // NotificationObserver implementation.
-  void Observe(int type,
-               const NotificationSource& source,
-               const NotificationDetails& details) override;
-
   // Returns whether the given RenderFrameHost (or its associated
   // RenderViewHost) is on the list of swapped out RenderFrameHosts.
   bool IsRVHOnSwappedOutList(RenderViewHostImpl* rvh) const;
   bool IsOnSwappedOutList(RenderFrameHostImpl* rfh) const;
 
-  // Returns the swapped out RenderViewHost or RenderFrameHost for the given
-  // SiteInstance, if any. This method is *deprecated* and
-  // GetRenderFrameProxyHost should be used.
+  // Returns the swapped out RenderViewHost for the given SiteInstance, if any.
+  // This method is *deprecated* and GetRenderFrameProxyHost should be used.
   RenderViewHostImpl* GetSwappedOutRenderViewHost(SiteInstance* instance) const;
+
+  // Returns the RenderFrameProxyHost for the given SiteInstance, if any.
   RenderFrameProxyHost* GetRenderFrameProxyHost(
       SiteInstance* instance) const;
 
   // Returns whether |render_frame_host| is on the pending deletion list.
   bool IsPendingDeletion(RenderFrameHostImpl* render_frame_host);
 
   // If |render_frame_host| is on the pending deletion list, this deletes it.
   // Returns whether it was deleted.
   bool DeleteFromPendingList(RenderFrameHostImpl* render_frame_host);
 
@@ skipping 64 matching lines @@
   // |outer_contents_site_instance|. The frame in outer WebContents that is
   // hosting the inner WebContents is |render_frame_host|, and the frame will
   // be swapped out with the proxy.
   void CreateOuterDelegateProxy(SiteInstance* outer_contents_site_instance,
                                 RenderFrameHostImpl* render_frame_host);
 
   // Sets the child RenderWidgetHostView for this frame, which must be part of
   // an inner WebContents.
   void SetRWHViewForInnerContents(RenderWidgetHostView* child_rwhv);
 
+  // Returns a copy of the map of proxy hosts. The keys are SiteInstance IDs,
+  // the values are RenderFrameProxyHosts.
+  std::map<int, RenderFrameProxyHost*> GetAllProxyHostsForTesting();
+
  private:
-  friend class FrameTreeVisualizer;
   friend class NavigatorTestWithBrowserSideNavigation;
   friend class RenderFrameHostManagerTest;
   friend class TestWebContents;
 
   // Stores information regarding a SiteInstance targeted at a specific URL to
   // allow for comparisons without having to actually create new instances. It
   // can point to an existing one or store the details needed to create a new
   // one.
   struct CONTENT_EXPORT SiteInstanceDescriptor {
     explicit SiteInstanceDescriptor(content::SiteInstance* site_instance)
@@ skipping 210 matching lines @@
       ui::PageTransition transition,
       bool dest_is_restore,
       bool dest_is_view_source_mode,
       const GlobalRequestID& transferred_request_id,
       int bindings);
 
   // Called when a renderer process is starting to close.  We should not
   // schedule new navigations in its swapped out RenderFrameHosts after this.
   void RendererProcessClosing(RenderProcessHost* render_process_host);
 
-  // Helper method to delete a RenderFrameProxyHost from the list, if one exists
-  // for the given |instance|.
-  void DeleteRenderFrameProxyHost(SiteInstance* instance);
-
   // For use in creating RenderFrameHosts.
   FrameTreeNode* frame_tree_node_;
 
   // Our delegate, not owned by us. Guaranteed non-NULL.
   Delegate* delegate_;
 
   // Implemented by the owner of this class.  These delegates are installed into
   // all the RenderFrameHosts that we create.
   RenderFrameHostDelegate* render_frame_delegate_;
   RenderViewHostDelegate* render_view_delegate_;
@@ skipping 26 matching lines @@
   scoped_ptr<CrossSiteTransferringRequest> cross_site_transferring_request_;
 
   // If either of these is non-NULL, the pending navigation is to a chrome:
   // page. The scoped_ptr is used if pending_web_ui_ != web_ui_, the WeakPtr is
   // used for when they reference the same object. If either is non-NULL, the
   // other should be NULL.
   // Note: These are not used in PlzNavigate.
   scoped_ptr<WebUIImpl> pending_web_ui_;
   base::WeakPtr<WebUIImpl> pending_and_current_web_ui_;
 
-  // A map of site instance ID to RenderFrameProxyHosts.
-  typedef base::hash_map<int32, RenderFrameProxyHost*> RenderFrameProxyHostMap;
-  RenderFrameProxyHostMap proxy_hosts_;
+  class RenderFrameProxyHostMap;
+  scoped_ptr<RenderFrameProxyHostMap> proxy_hosts_;
 
   // A list of RenderFrameHosts waiting to shut down after swapping out.  We use
   // a linked list since we expect frequent deletes and no indexed access, and
   // because sets don't appear to support linked_ptrs.
   typedef std::list<linked_ptr<RenderFrameHostImpl> > RFHPendingDeleteList;
   RFHPendingDeleteList pending_delete_hosts_;
 
   // The intersitial page currently shown if any, not own by this class
   // (the InterstitialPage is self-owned, it deletes itself when hidden).
   InterstitialPageImpl* interstitial_page_;
 
-  NotificationRegistrar registrar_;
-
   // PlzNavigate
   // These members store a speculative RenderFrameHost and WebUI. They are
   // created early in a navigation so a renderer process can be started in
   // parallel, if needed. This is purely a performance optimization and is not
   // required for correct behavior. The created RenderFrameHost might be
   // discarded later on if the final URL's SiteInstance isn't compatible with
   // what was used to create it.
   // Note: PlzNavigate only uses speculative RenderFrameHost and WebUI, not
   // the pending ones.
   scoped_ptr<RenderFrameHostImpl> speculative_render_frame_host_;
   scoped_ptr<WebUIImpl> speculative_web_ui_;
 
   // PlzNavigate
   // If true at navigation commit time the current WebUI will be kept instead of
   // creating a new one.
   bool should_reuse_web_ui_;
 
   base::WeakPtrFactory<RenderFrameHostManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_