Inside of content, prefer SiteInstanceImpl to SiteInstance.

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 <stdint.h>
 
 #include <list>
@@ skipping 176 matching lines @@
   // 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();
 
   // For arguments, see WebContentsImpl constructor.
-  void Init(SiteInstance* site_instance,
+  void Init(SiteInstanceImpl* site_instance,
             int32_t view_routing_id,
             int32_t frame_routing_id,
             int32_t widget_routing_id);
 
   // Returns the currently active RenderFrameHost.
   //
   // This will be non-NULL between Init() and Shutdown(). You may want to NULL
   // check it in many cases, however. Windows can send us messages during the
   // destruction process after it has been shut down.
   RenderFrameHostImpl* current_frame_host() const {
@@ skipping 118 matching lines @@
   void DidNavigateFrame(RenderFrameHostImpl* render_frame_host,
                         bool was_caused_by_user_gesture);
 
   // Called when this frame's opener is changed to the frame specified by
   // |opener_routing_id| in |source_site_instance|'s process.  This change
   // could come from either the current RenderFrameHost or one of the
   // proxies (e.g., window.open that targets a RemoteFrame by name).  The
   // updated opener will be forwarded to any other RenderFrameProxies and
   // RenderFrames for this FrameTreeNode.
   void DidChangeOpener(int opener_routing_id,
-                       SiteInstance* source_site_instance);
+                       SiteInstanceImpl* source_site_instance);
 
   // Creates and initializes a RenderFrameHost. If |view_routing_id_ptr|
   // is not nullptr it will be set to the routing id of the view associated with
   // the frame.
-  scoped_ptr<RenderFrameHostImpl> CreateRenderFrame(SiteInstance* instance,
+  scoped_ptr<RenderFrameHostImpl> CreateRenderFrame(SiteInstanceImpl* instance,
                                                     bool hidden,
                                                     int* view_routing_id_ptr);
 
   // Helper method to create and initialize a RenderFrameProxyHost and return
   // its routing id.
-  int CreateRenderFrameProxy(SiteInstance* instance);
+  int CreateRenderFrameProxy(SiteInstanceImpl* instance);
 
   // Creates proxies for a new child frame at FrameTreeNode |child| in all
   // SiteInstances for which the current frame has proxies.  This method is
   // called on the parent of a new child frame before the child leaves the
   // SiteInstance.
   void CreateProxiesForChildFrame(FrameTreeNode* child);
 
   // Sets the passed passed interstitial as the currently showing interstitial.
   // |interstitial_page| should be non NULL (use the remove_interstitial_page
   // method to unset the interstitial) and no interstitial page should be set
@@ skipping 40 matching lines @@
   // Deletes any proxy hosts associated with this node. Used during destruction
   // of WebContentsImpl.
   void ResetProxyHosts();
 
   void ClearRFHsPendingShutdown();
   void ClearWebUIInstances();
 
   // Returns the routing id for a RenderFrameHost or RenderFrameProxyHost
   // that has the given SiteInstance and is associated with this
   // RenderFrameHostManager. Returns MSG_ROUTING_NONE if none is found.
-  int GetRoutingIdForSiteInstance(SiteInstance* site_instance);
+  int GetRoutingIdForSiteInstance(SiteInstanceImpl* site_instance);
 
   // PlzNavigate
   // Notifies the RenderFrameHostManager that a new NavigationRequest has been
   // created and set in the FrameTreeNode so that it can speculatively create a
   // new RenderFrameHost (and potentially a new process) if needed.
   void DidCreateNavigationRequest(const NavigationRequest& request);
 
   // PlzNavigate
   // Called (possibly several times) during a navigation to select or create an
   // appropriate RenderFrameHost for the provided URL. The returned pointer will
@@ skipping 24 matching lines @@
   // Sends updated enforcement of strict mixed content checking to all
   // frame proxies when the frame changes its setting.
   void OnEnforceStrictMixedContentChecking(bool should_enforce);
 
   // Send updated origin to all frame proxies when the frame navigates to a new
   // origin.
   void OnDidUpdateOrigin(const url::Origin& origin,
                          bool is_potentially_trustworthy_unique_origin);
 
   void EnsureRenderViewInitialized(RenderViewHostImpl* render_view_host,
-                                   SiteInstance* instance);
+                                   SiteInstanceImpl* instance);
 
   // Creates swapped out RenderViews and RenderFrameProxies for this frame's
   // FrameTree and for its opener chain in the given SiteInstance. This allows
   // other tabs to send cross-process JavaScript calls to their opener(s) and
   // to any other frames in the opener's FrameTree (e.g., supporting calls like
   // window.opener.opener.frames[x][y]).  Does not create proxies for the
   // subtree rooted at |skip_this_node| (e.g., if a node is being navigated, it
   // can be passed here to prevent proxies from being created for it, in
   // case it is in the same FrameTree as another node on its opener chain).
-  void CreateOpenerProxies(SiteInstance* instance,
+  void CreateOpenerProxies(SiteInstanceImpl* instance,
                            FrameTreeNode* skip_this_node);
 
   // Ensure that this frame has proxies in all SiteInstances that can discover
   // this frame by name (e.g., via window.open("", "frame_name")).  See
   // https://crbug.com/511474.
   void CreateProxiesForNewNamedFrame();
 
   // Returns a routing ID for the current FrameTreeNode's opener node in the
   // given SiteInstance.  May return a routing ID of either a RenderFrameHost
   // (if opener's current or pending RFH has SiteInstance |instance|) or a
   // RenderFrameProxyHost.  Returns MSG_ROUTING_NONE if there is no opener, or
   // if the opener node doesn't have a proxy for |instance|.
-  int GetOpenerRoutingID(SiteInstance* instance);
+  int GetOpenerRoutingID(SiteInstanceImpl* instance);
 
   // Called on the RFHM of the inner WebContents to create a
   // RenderFrameProxyHost in its outer WebContents's SiteInstance,
   // |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,
+  void CreateOuterDelegateProxy(SiteInstanceImpl* 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 the number of RenderFrameProxyHosts for this frame.
   int GetProxyCount();
 
   // Sends an IPC message to every process in the FrameTree. This should only be
@@ skipping 30 matching lines @@
     RELATED,
     // The default subframe SiteInstance for the current browsing instance.
     RELATED_DEFAULT_SUBFRAME,
   };
 
   // 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)
+    explicit SiteInstanceDescriptor(content::SiteInstanceImpl* site_instance)
         : existing_site_instance(site_instance),
           relation(SiteInstanceRelation::UNRELATED) {}
 
     SiteInstanceDescriptor(BrowserContext* browser_context,
                            GURL dest_url,
                            SiteInstanceRelation relation_to_current);
 
     // Set with an existing SiteInstance to be reused.
-    content::SiteInstance* existing_site_instance;
+    content::SiteInstanceImpl* existing_site_instance;
 
     // In case |existing_site_instance| is null, specify a new site URL.
     GURL new_site_url;
 
     // In case |existing_site_instance| is null, specify how the new site is
     // related to the current BrowsingInstance.
     SiteInstanceRelation relation;
   };
 
   // Create a RenderFrameProxyHost owned by this object.
-  RenderFrameProxyHost* CreateRenderFrameProxyHost(SiteInstance* site_instance,
-                                                   RenderViewHostImpl* rvh);
+  RenderFrameProxyHost* CreateRenderFrameProxyHost(
+      SiteInstanceImpl* site_instance,
+      RenderViewHostImpl* rvh);
   // Delete a RenderFrameProxyHost owned by this object.
-  void DeleteRenderFrameProxyHost(SiteInstance* site_instance);
+  void DeleteRenderFrameProxyHost(SiteInstanceImpl* site_instance);
 
   // 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 for the navigation from |current_effective_url| to
   // |new_effective_url|, a new SiteInstance and BrowsingInstance should be
   // created (even if we are in a process model that doesn't usually swap).
   // This forces a process swap and severs script connections with existing
   // tabs.  Cases where this can happen include transitions between WebUI and
   // regular web pages. |new_site_instance| may be null.
   // If there is no current NavigationEntry, then |current_is_view_source_mode|
   // should be the same as |new_is_view_source_mode|.
   //
   // We use the effective URL here, since that's what is used in the
   // SiteInstance's site and when we later call IsSameWebSite.  If there is no
   // current NavigationEntry, check the current SiteInstance's site, which might
   // already be committed to a Web UI URL (such as the NTP).
   bool ShouldSwapBrowsingInstancesForNavigation(
       const GURL& current_effective_url,
       bool current_is_view_source_mode,
-      SiteInstance* new_site_instance,
+      SiteInstanceImpl* new_site_instance,
       const GURL& new_effective_url,
       bool new_is_view_source_mode) const;
 
   // Returns the SiteInstance to use for the navigation.
-  scoped_refptr<SiteInstance> GetSiteInstanceForNavigation(
+  scoped_refptr<SiteInstanceImpl> GetSiteInstanceForNavigation(
       const GURL& dest_url,
-      SiteInstance* source_instance,
-      SiteInstance* dest_instance,
-      SiteInstance* candidate_instance,
+      SiteInstanceImpl* source_instance,
+      SiteInstanceImpl* dest_instance,
+      SiteInstanceImpl* candidate_instance,
       ui::PageTransition transition,
       bool dest_is_restore,
       bool dest_is_view_source_mode);
 
   // Returns a descriptor of the appropriate SiteInstance object for the given
   // |dest_url|, possibly reusing the current, source or destination
   // SiteInstance. The actual SiteInstance can then be obtained calling
   // ConvertToSiteInstance with the descriptor.
   //
   // |source_instance| is the SiteInstance of the frame that initiated the
   // navigation. |current_instance| is the SiteInstance of the frame that is
   // currently navigating. |dest_instance| is a predetermined SiteInstance that
   // will be used if not null.
   // For example, if you have a parent frame A, which has a child frame B, and
   // A is trying to change the src attribute of B, this will cause a navigation
   // where the source SiteInstance is A and B is the current SiteInstance.
   //
   // This is a helper function for GetSiteInstanceForNavigation.
   SiteInstanceDescriptor DetermineSiteInstanceForURL(
       const GURL& dest_url,
-      SiteInstance* source_instance,
-      SiteInstance* current_instance,
-      SiteInstance* dest_instance,
+      SiteInstanceImpl* source_instance,
+      SiteInstanceImpl* current_instance,
+      SiteInstanceImpl* dest_instance,
       ui::PageTransition transition,
       bool dest_is_restore,
       bool dest_is_view_source_mode,
       bool force_browsing_instance_swap);
 
   // Converts a SiteInstanceDescriptor to the actual SiteInstance it describes.
   // If a |candidate_instance| is provided (is not nullptr) and it matches the
   // description, it is returned as is.
-  scoped_refptr<SiteInstance> ConvertToSiteInstance(
+  scoped_refptr<SiteInstanceImpl> ConvertToSiteInstance(
       const SiteInstanceDescriptor& descriptor,
-      SiteInstance* candidate_instance);
+      SiteInstanceImpl* candidate_instance);
 
   // Returns true if |candidate| is currently on the same web site as dest_url.
   bool IsCurrentlySameSite(RenderFrameHostImpl* candidate,
                            const GURL& dest_url);
 
   // Creates a new RenderFrameHostImpl for the |new_instance| and assign it to
   // |pending_render_frame_host_| while respecting the opener route if needed
   // and stores it in pending_render_frame_host_.
-  void CreatePendingRenderFrameHost(SiteInstance* old_instance,
-                                    SiteInstance* new_instance);
+  void CreatePendingRenderFrameHost(SiteInstanceImpl* old_instance,
+                                    SiteInstanceImpl* new_instance);
 
   // Ensure that we have created all needed proxies for a new RFH with
   // SiteInstance |new_instance|: (1) create swapped-out RVHs and proxies for
   // the new RFH's opener chain if we are staying in the same BrowsingInstance;
   // (2) Create proxies for the new RFH's SiteInstance in its own frame tree.
-  void CreateProxiesForNewRenderFrameHost(SiteInstance* old_instance,
-                                          SiteInstance* new_instance);
+  void CreateProxiesForNewRenderFrameHost(SiteInstanceImpl* old_instance,
+                                          SiteInstanceImpl* new_instance);
 
   // Traverse the opener chain and populate |opener_frame_trees| with
   // all FrameTrees accessible by following frame openers of nodes in the
   // given node's FrameTree. |opener_frame_trees| is ordered so that openers
   // of smaller-indexed entries point to larger-indexed entries (i.e., this
   // node's FrameTree is at index 0, its opener's FrameTree is at index 1,
   // etc). If the traversal encounters a node with an opener pointing to a
   // FrameTree that has already been traversed (such as when there's a cycle),
   // the node is added to |nodes_with_back_links|.
   void CollectOpenerFrameTrees(
       std::vector<FrameTree*>* opener_frame_trees,
       base::hash_set<FrameTreeNode*>* nodes_with_back_links);
 
   // Create swapped out RenderViews and RenderFrameProxies in the given
   // SiteInstance for the current node's FrameTree.  Used as a helper function
   // in CreateOpenerProxies for creating proxies in each FrameTree on the
   // opener chain.  Don't create proxies for the subtree rooted at
   // |skip_this_node|.
-  void CreateOpenerProxiesForFrameTree(SiteInstance* instance,
+  void CreateOpenerProxiesForFrameTree(SiteInstanceImpl* instance,
                                        FrameTreeNode* skip_this_node);
 
   // Creates a RenderFrameHost and corresponding RenderViewHost if necessary.
   scoped_ptr<RenderFrameHostImpl> CreateRenderFrameHost(
-      SiteInstance* instance,
+      SiteInstanceImpl* instance,
       int32_t view_routing_id,
       int32_t frame_routing_id,
       int32_t widget_routing_id,
       bool hidden);
 
   // PlzNavigate
   // Create and initialize a speculative RenderFrameHost for an ongoing
   // navigation. It might be destroyed and re-created later if the navigation
   // is redirected to a different SiteInstance.
-  bool CreateSpeculativeRenderFrameHost(SiteInstance* old_instance,
-                                        SiteInstance* new_instance);
+  bool CreateSpeculativeRenderFrameHost(SiteInstanceImpl* old_instance,
+                                        SiteInstanceImpl* new_instance);
 
   // Initialization for RenderFrameHost uses the same sequence as InitRenderView
   // above.
   bool InitRenderFrame(RenderFrameHostImpl* render_frame_host);
 
   // Makes the pending WebUI on the current RenderFrameHost active. Call this
   // when the current RenderFrameHost commits and it has a pending WebUI.
   void CommitPendingWebUI();
 
   // Sets the pending RenderFrameHost to be the active one. Call when the
@@ skipping 31 matching lines @@
   // Clears pending_render_frame_host_, returning it to the caller for disposal.
   scoped_ptr<RenderFrameHostImpl> UnsetPendingRenderFrameHost();
 
   // Helper method to set the active RenderFrameHost. Returns the old
   // RenderFrameHost and updates counts.
   scoped_ptr<RenderFrameHostImpl> SetRenderFrameHost(
       scoped_ptr<RenderFrameHostImpl> render_frame_host);
 
   RenderFrameHostImpl* UpdateStateForNavigate(
       const GURL& dest_url,
-      SiteInstance* source_instance,
-      SiteInstance* dest_instance,
+      SiteInstanceImpl* source_instance,
+      SiteInstanceImpl* dest_instance,
       ui::PageTransition transition,
       bool dest_is_restore,
       bool dest_is_view_source_mode,
       const GlobalRequestID& transferred_request_id,
       int bindings);
 
   // Updates the pending WebUI of the current RenderFrameHost for a same-site
   // navigation.
   void UpdatePendingWebUIOnCurrentFrameHost(const GURL& dest_url,
                                             int entry_bindings);
@@ skipping 57 matching lines @@
   scoped_ptr<RenderFrameHostImpl> speculative_render_frame_host_;
 
   base::WeakPtrFactory<RenderFrameHostManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_