render_frame_host_impl.h revision 23730a6e56a168d1879203e4b3819bb36e3d8f1f
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_RENDER_FRAME_HOST_IMPL_H_ 6#define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_ 7 8#include <map> 9#include <vector> 10 11#include "base/callback.h" 12#include "base/compiler_specific.h" 13#include "base/strings/string16.h" 14#include "base/time/time.h" 15#include "content/common/content_export.h" 16#include "content/public/browser/render_frame_host.h" 17#include "content/public/common/page_transition_types.h" 18 19class GURL; 20struct FrameHostMsg_DidFailProvisionalLoadWithError_Params; 21struct FrameHostMsg_OpenURL_Params; 22struct FrameMsg_Navigate_Params; 23 24namespace base { 25class FilePath; 26class ListValue; 27} 28 29namespace content { 30 31class CrossProcessFrameConnector; 32class CrossSiteTransferringRequest; 33class FrameTree; 34class FrameTreeNode; 35class RenderFrameHostDelegate; 36class RenderProcessHost; 37class RenderViewHostImpl; 38struct ContextMenuParams; 39struct GlobalRequestID; 40struct Referrer; 41 42class CONTENT_EXPORT RenderFrameHostImpl : public RenderFrameHost { 43 public: 44 static RenderFrameHostImpl* FromID(int process_id, int routing_id); 45 46 virtual ~RenderFrameHostImpl(); 47 48 // RenderFrameHost 49 virtual int GetRoutingID() OVERRIDE; 50 virtual SiteInstance* GetSiteInstance() OVERRIDE; 51 virtual RenderProcessHost* GetProcess() OVERRIDE; 52 virtual RenderFrameHost* GetParent() OVERRIDE; 53 virtual const std::string& GetFrameName() OVERRIDE; 54 virtual bool IsCrossProcessSubframe() OVERRIDE; 55 virtual GURL GetLastCommittedURL() OVERRIDE; 56 virtual gfx::NativeView GetNativeView() OVERRIDE; 57 virtual void DispatchBeforeUnload(bool for_cross_site_transition) OVERRIDE; 58 virtual void NotifyContextMenuClosed( 59 const CustomContextMenuContext& context) OVERRIDE; 60 virtual void ExecuteCustomContextMenuCommand( 61 int action, const CustomContextMenuContext& context) OVERRIDE; 62 virtual void Cut() OVERRIDE; 63 virtual void Copy() OVERRIDE; 64 virtual void Paste() OVERRIDE; 65 virtual void InsertCSS(const std::string& css) OVERRIDE; 66 virtual void ExecuteJavaScript( 67 const base::string16& javascript) OVERRIDE; 68 virtual void ExecuteJavaScript( 69 const base::string16& javascript, 70 const JavaScriptResultCallback& callback) OVERRIDE; 71 virtual RenderViewHost* GetRenderViewHost() OVERRIDE; 72 73 // IPC::Sender 74 virtual bool Send(IPC::Message* msg) OVERRIDE; 75 76 // IPC::Listener 77 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE; 78 79 void Init(); 80 int routing_id() const { return routing_id_; } 81 void OnCreateChildFrame(int new_routing_id, 82 const std::string& frame_name); 83 84 RenderViewHostImpl* render_view_host() { return render_view_host_; } 85 RenderFrameHostDelegate* delegate() { return delegate_; } 86 FrameTreeNode* frame_tree_node() { return frame_tree_node_; } 87 88 // This function is called when this is a swapped out RenderFrameHost that 89 // lives in the same process as the parent frame. The 90 // |cross_process_frame_connector| allows the non-swapped-out 91 // RenderFrameHost for a frame to communicate with the parent process 92 // so that it may composite drawing data. 93 // 94 // Ownership is not transfered. 95 void set_cross_process_frame_connector( 96 CrossProcessFrameConnector* cross_process_frame_connector) { 97 cross_process_frame_connector_ = cross_process_frame_connector; 98 } 99 100 // Returns a bitwise OR of bindings types that have been enabled for this 101 // RenderFrameHostImpl's RenderView. See BindingsPolicy for details. 102 // TODO(creis): Make bindings frame-specific, to support cases like <webview>. 103 int GetEnabledBindings(); 104 105 // Called on the pending RenderFrameHost when the network response is ready to 106 // commit. We should ensure that the old RenderFrameHost runs its unload 107 // handler and determine whether a transfer to a different RenderFrameHost is 108 // needed. 109 void OnCrossSiteResponse( 110 const GlobalRequestID& global_request_id, 111 scoped_ptr<CrossSiteTransferringRequest> cross_site_transferring_request, 112 const std::vector<GURL>& transfer_url_chain, 113 const Referrer& referrer, 114 PageTransition page_transition, 115 bool should_replace_current_entry); 116 117 // Hack to get this subframe to swap out, without yet moving over all the 118 // SwapOut state and machinery from RenderViewHost. 119 void SwapOut(); 120 void OnSwappedOut(bool timed_out); 121 bool is_swapped_out() { return is_swapped_out_; } 122 void set_swapped_out(bool is_swapped_out) { 123 is_swapped_out_ = is_swapped_out; 124 } 125 126 // Sets the RVH for |this| as pending shutdown. |on_swap_out| will be called 127 // when the SwapOutACK is received. 128 void SetPendingShutdown(const base::Closure& on_swap_out); 129 130 // TODO(nasko): This method is public so RenderViewHostImpl::Navigate can 131 // call it directly. It should be made private once Navigate moves here. 132 void OnDidStartLoading(); 133 134 // Sends the given navigation message. Use this rather than sending it 135 // yourself since this does the internal bookkeeping described below. This 136 // function takes ownership of the provided message pointer. 137 // 138 // If a cross-site request is in progress, we may be suspended while waiting 139 // for the onbeforeunload handler, so this function might buffer the message 140 // rather than sending it. 141 void Navigate(const FrameMsg_Navigate_Params& params); 142 143 // Load the specified URL; this is a shortcut for Navigate(). 144 void NavigateToURL(const GURL& url); 145 146 protected: 147 friend class RenderFrameHostFactory; 148 149 // TODO(nasko): Remove dependency on RenderViewHost here. RenderProcessHost 150 // should be the abstraction needed here, but we need RenderViewHost to pass 151 // into WebContentsObserver::FrameDetached for now. 152 RenderFrameHostImpl(RenderViewHostImpl* render_view_host, 153 RenderFrameHostDelegate* delegate, 154 FrameTree* frame_tree, 155 FrameTreeNode* frame_tree_node, 156 int routing_id, 157 bool is_swapped_out); 158 159 private: 160 friend class TestRenderFrameHost; 161 friend class TestRenderViewHost; 162 163 // IPC Message handlers. 164 void OnDetach(); 165 void OnFrameFocused(); 166 void OnOpenURL(const FrameHostMsg_OpenURL_Params& params); 167 void OnDidStartProvisionalLoadForFrame(int parent_routing_id, 168 bool main_frame, 169 const GURL& url); 170 void OnDidFailProvisionalLoadWithError( 171 const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params); 172 void OnDidFailLoadWithError( 173 const GURL& url, 174 bool is_main_frame, 175 int error_code, 176 const base::string16& error_description); 177 void OnDidRedirectProvisionalLoad(int32 page_id, 178 const GURL& source_url, 179 const GURL& target_url); 180 void OnNavigate(const IPC::Message& msg); 181 void OnDidStopLoading(); 182 void OnBeforeUnloadACK( 183 bool proceed, 184 const base::TimeTicks& renderer_before_unload_start_time, 185 const base::TimeTicks& renderer_before_unload_end_time); 186 void OnSwapOutACK(); 187 void OnContextMenu(const ContextMenuParams& params); 188 void OnJavaScriptExecuteResponse(int id, const base::ListValue& result); 189 190 // Returns whether the given URL is allowed to commit in the current process. 191 // This is a more conservative check than RenderProcessHost::FilterURL, since 192 // it will be used to kill processes that commit unauthorized URLs. 193 bool CanCommitURL(const GURL& url); 194 195 // For now, RenderFrameHosts indirectly keep RenderViewHosts alive via a 196 // refcount that calls Shutdown when it reaches zero. This allows each 197 // RenderFrameHostManager to just care about RenderFrameHosts, while ensuring 198 // we have a RenderViewHost for each RenderFrameHost. 199 // TODO(creis): RenderViewHost will eventually go away and be replaced with 200 // some form of page context. 201 RenderViewHostImpl* render_view_host_; 202 203 RenderFrameHostDelegate* delegate_; 204 205 // |cross_process_frame_connector_| passes messages from an out-of-process 206 // child frame to the parent process for compositing. 207 // 208 // This is only non-NULL when this is the swapped out RenderFrameHost in 209 // the same site instance as this frame's parent. 210 // 211 // See the class comment above CrossProcessFrameConnector for more 212 // information. 213 // 214 // This will move to RenderFrameProxyHost when that class is created. 215 CrossProcessFrameConnector* cross_process_frame_connector_; 216 217 // Reference to the whole frame tree that this RenderFrameHost belongs to. 218 // Allows this RenderFrameHost to add and remove nodes in response to 219 // messages from the renderer requesting DOM manipulation. 220 FrameTree* frame_tree_; 221 222 // The FrameTreeNode which this RenderFrameHostImpl is hosted in. 223 FrameTreeNode* frame_tree_node_; 224 225 // The mapping of pending JavaScript calls created by 226 // ExecuteJavaScript and their corresponding callbacks. 227 std::map<int, JavaScriptResultCallback> javascript_callbacks_; 228 229 int routing_id_; 230 bool is_swapped_out_; 231 232 // When the last BeforeUnload message was sent. 233 base::TimeTicks send_before_unload_start_time_; 234 235 DISALLOW_COPY_AND_ASSIGN(RenderFrameHostImpl); 236}; 237 238} // namespace content 239 240#endif // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_ 241