1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_BROWSER_FRAME_HOST_FRAME_TREE_H_ 6 #define CONTENT_BROWSER_FRAME_HOST_FRAME_TREE_H_ 7 8 #include <string> 9 10 #include "base/callback.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "content/browser/frame_host/frame_tree_node.h" 13 #include "content/common/content_export.h" 14 15 namespace content { 16 17 class FrameTreeNode; 18 class Navigator; 19 class RenderFrameHostDelegate; 20 class RenderProcessHost; 21 class RenderViewHostDelegate; 22 class RenderViewHostImpl; 23 class RenderFrameHostManager; 24 class RenderWidgetHostDelegate; 25 26 // Represents the frame tree for a page. With the exception of the main frame, 27 // all FrameTreeNodes will be created/deleted in response to frame attach and 28 // detach events in the DOM. 29 // 30 // The main frame's FrameTreeNode is special in that it is reused. This allows 31 // it to serve as an anchor for state that needs to persist across top-level 32 // page navigations. 33 // 34 // TODO(ajwong): Move NavigationController ownership to the main frame 35 // FrameTreeNode. Possibly expose access to it from here. 36 // 37 // This object is only used on the UI thread. 38 class CONTENT_EXPORT FrameTree { 39 public: 40 // Each FrameTreeNode will default to using the given |navigator| for 41 // navigation tasks in the frame. 42 // A set of delegates are remembered here so that we can create 43 // RenderFrameHostManagers. 44 // TODO(creis): This set of delegates will change as we move things to 45 // Navigator. 46 FrameTree(Navigator* navigator, 47 RenderFrameHostDelegate* render_frame_delegate, 48 RenderViewHostDelegate* render_view_delegate, 49 RenderWidgetHostDelegate* render_widget_delegate, 50 RenderFrameHostManager::Delegate* manager_delegate); 51 ~FrameTree(); 52 53 // Returns the FrameTreeNode with the given |frame_tree_node_id|. 54 static FrameTreeNode* GloballyFindByID(int64 frame_tree_node_id); 55 56 FrameTreeNode* root() const { return root_.get(); } 57 58 // Returns the FrameTreeNode with the given |frame_tree_node_id| if it is part 59 // of this FrameTree. 60 FrameTreeNode* FindByID(int64 frame_tree_node_id); 61 62 // Returns the FrameTreeNode with the given renderer-specific |routing_id|. 63 FrameTreeNode* FindByRoutingID(int routing_id, int process_id); 64 65 // Executes |on_node| on each node in the frame tree. If |on_node| returns 66 // false, terminates the iteration immediately. Returning false is useful 67 // if |on_node| is just doing a search over the tree. The iteration proceeds 68 // top-down and visits a node before adding its children to the queue, making 69 // it safe to remove children during the callback. 70 void ForEach(const base::Callback<bool(FrameTreeNode*)>& on_node) const; 71 72 // Frame tree manipulation routines. 73 RenderFrameHostImpl* AddFrame(FrameTreeNode* parent, 74 int process_id, 75 int new_routing_id, 76 const std::string& frame_name); 77 void RemoveFrame(FrameTreeNode* child); 78 79 // This method walks the entire frame tree and creates a RenderFrameProxyHost 80 // for the given |site_instance| in each node except the |source| one -- 81 // the source will have a RenderFrameHost. It assumes that no frame tree 82 // nodes already have RenderFrameProxyHost for the given |site_instance|. 83 void CreateProxiesForSiteInstance( 84 FrameTreeNode* source, 85 SiteInstance* site_instance); 86 87 // Clears process specific-state after a main frame process swap. 88 // This destroys most of the frame tree but retains the root node so that 89 // navigation state may be kept on it between process swaps. Used to 90 // support bookkeeping for top-level navigations. 91 // TODO(creis): Look into how we can remove the need for this method. 92 void ResetForMainFrameSwap(); 93 94 // Update the frame tree after a process exits. Any nodes currently using the 95 // given |render_view_host| will lose all their children. 96 // TODO(creis): This should take a RenderProcessHost once RenderFrameHost 97 // knows its process. Until then, we would just be asking the RenderViewHost 98 // for its process, so we'll skip that step. 99 void RenderProcessGone(RenderViewHost* render_view_host); 100 101 // Convenience accessor for the main frame's RenderFrameHostImpl. 102 RenderFrameHostImpl* GetMainFrame() const; 103 104 // Returns the focused frame. 105 FrameTreeNode* GetFocusedFrame(); 106 107 // Sets the focused frame. 108 void SetFocusedFrame(FrameTreeNode* node); 109 110 // Allows a client to listen for frame removal. The listener should expect 111 // to receive the RenderViewHostImpl containing the frame and the renderer- 112 // specific frame routing ID of the removed frame. 113 void SetFrameRemoveListener( 114 const base::Callback<void(RenderFrameHost*)>& on_frame_removed); 115 116 // Creates a RenderViewHost for a new RenderFrameHost in the given 117 // |site_instance|. The RenderViewHost will have its Shutdown method called 118 // when all of the RenderFrameHosts using it are deleted. 119 RenderViewHostImpl* CreateRenderViewHost(SiteInstance* site_instance, 120 int routing_id, 121 int main_frame_routing_id, 122 bool swapped_out, 123 bool hidden); 124 125 // Returns the existing RenderViewHost for a new RenderFrameHost. 126 // There should always be such a RenderViewHost, because the main frame 127 // RenderFrameHost for each SiteInstance should be created before subframes. 128 RenderViewHostImpl* GetRenderViewHost(SiteInstance* site_instance); 129 130 // Keeps track of which RenderFrameHosts are using each RenderViewHost. When 131 // the number drops to zero, we call Shutdown on the RenderViewHost. 132 void RegisterRenderFrameHost(RenderFrameHostImpl* render_frame_host); 133 void UnregisterRenderFrameHost(RenderFrameHostImpl* render_frame_host); 134 135 private: 136 typedef base::hash_map<int, RenderViewHostImpl*> RenderViewHostMap; 137 typedef std::multimap<int, RenderViewHostImpl*> RenderViewHostMultiMap; 138 139 // These delegates are installed into all the RenderViewHosts and 140 // RenderFrameHosts that we create. 141 RenderFrameHostDelegate* render_frame_delegate_; 142 RenderViewHostDelegate* render_view_delegate_; 143 RenderWidgetHostDelegate* render_widget_delegate_; 144 RenderFrameHostManager::Delegate* manager_delegate_; 145 146 // Map of SiteInstance ID to a RenderViewHost. This allows us to look up the 147 // RenderViewHost for a given SiteInstance when creating RenderFrameHosts. 148 // Combined with the refcount on RenderViewHost, this allows us to call 149 // Shutdown on the RenderViewHost and remove it from the map when no more 150 // RenderFrameHosts are using it. 151 // 152 // Must be declared before |root_| so that it is deleted afterward. Otherwise 153 // the map will be cleared before we delete the RenderFrameHosts in the tree. 154 RenderViewHostMap render_view_host_map_; 155 156 // Map of SiteInstance ID to RenderViewHosts that are pending shutdown. The 157 // renderers of these RVH are currently executing the unload event in 158 // background. When the SwapOutACK is received, they will be deleted. In the 159 // meantime, they are kept in this map, as they should not be reused (part of 160 // their state is already gone away). 161 RenderViewHostMultiMap render_view_host_pending_shutdown_map_; 162 163 scoped_ptr<FrameTreeNode> root_; 164 165 int64 focused_frame_tree_node_id_; 166 167 base::Callback<void(RenderFrameHost*)> on_frame_removed_; 168 169 DISALLOW_COPY_AND_ASSIGN(FrameTree); 170 }; 171 172 } // namespace content 173 174 #endif // CONTENT_BROWSER_FRAME_HOST_FRAME_TREE_H_ 175
