content/browser/frame_host/render_frame_proxy_host.h

   1 // Copyright 2014 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_PROXY_HOST_H_
   6 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_PROXY_HOST_H_
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "content/browser/frame_host/render_frame_host_impl.h"
  10 #include "content/browser/site_instance_impl.h"
  11 #include "ipc/ipc_listener.h"
  12 #include "ipc/ipc_sender.h"
  13
  14 namespace content {
  15
  16 class CrossProcessFrameConnector;
  17 class FrameTreeNode;
  18 class RenderProcessHost;
  19 class RenderFrameHostImpl;
  20 class RenderViewHostImpl;
  21 class RenderWidgetHostView;
  22
  23 // When a page's frames are rendered by multiple processes, each renderer has a
  24 // full copy of the frame tree. It has full RenderFrames for the frames it is
  25 // responsible for rendering and placeholder objects (i.e., RenderFrameProxies)
  26 // for frames rendered by other processes.
  27 //
  28 // This class is the browser-side host object for the placeholder. Each node in
  29 // the frame tree has a RenderFrameHost for the active SiteInstance and a set
  30 // of RenderFrameProxyHost objects - one for all other SiteInstances with
  31 // references to this frame. The proxies allow us to keep existing window
  32 // references valid over cross-process navigations and route cross-site
  33 // asynchronous JavaScript calls, such as postMessage.
  34 //
  35 // For now, RenderFrameProxyHost is created when a RenderFrameHost is swapped
  36 // out and acts just as a wrapper. It is destroyed when the RenderFrameHost is
  37 // swapped back in or is no longer referenced and is therefore deleted.
  38 //
  39 // Long term, RenderFrameProxyHost will be created whenever a cross-site
  40 // navigation occurs and a reference to the frame navigating needs to be kept
  41 // alive. A RenderFrameProxyHost and a RenderFrameHost for the same SiteInstance
  42 // can exist at the same time, but only one will be "active" at a time.
  43 // There are two cases where the two objects will coexist:
  44 // * When navigating cross-process and there is already a RenderFrameProxyHost
  45 // for the new SiteInstance. A pending RenderFrameHost is created, but it is
  46 // not used until it commits. At that point, RenderFrameHostManager transitions
  47 // the pending RenderFrameHost to the active one and deletes the proxy.
  48 // * When navigating cross-process and the existing document has an unload
  49 // event handler. When the new navigation commits, RenderFrameHostManager
  50 // creates a RenderFrameProxyHost for the old SiteInstance and uses it going
  51 // forward. It also instructs the RenderFrameHost to run the unload event
  52 // handler and is kept alive for the duration. Once the event handling is
  53 // complete, the RenderFrameHost is deleted.
  54 class RenderFrameProxyHost
  55     : public IPC::Listener,
  56       public IPC::Sender {
  57  public:
  58   static RenderFrameProxyHost* FromID(int process_id, int routing_id);
  59
  60   RenderFrameProxyHost(SiteInstance* site_instance,
  61                        FrameTreeNode* frame_tree_node);
  62   virtual ~RenderFrameProxyHost();
  63
  64   RenderProcessHost* GetProcess() {
  65     return site_instance_->GetProcess();
  66   }
  67
  68   // Initializes the object and creates the RenderFrameProxy in the process
  69   // for the SiteInstance.
  70   bool InitRenderFrameProxy();
  71
  72   int GetRoutingID() {
  73     return routing_id_;
  74   }
  75
  76   SiteInstance* GetSiteInstance() {
  77     return site_instance_.get();
  78   }
  79
  80   FrameTreeNode* frame_tree_node() const { return frame_tree_node_; };
  81
  82   void SetChildRWHView(RenderWidgetHostView* view);
  83
  84   // TODO(nasko): The following methods should be removed once we don't have a
  85   // swapped out state on RenderFrameHosts. See https://crbug.com/357747.
  86   RenderFrameHostImpl* render_frame_host() {
  87     return render_frame_host_.get();
  88   }
  89   RenderViewHostImpl* GetRenderViewHost();
  90
  91   void TakeFrameHostOwnership(
  92       scoped_ptr<RenderFrameHostImpl> render_frame_host) {
  93     render_frame_host_ = render_frame_host.Pass();
  94   }
  95   scoped_ptr<RenderFrameHostImpl> PassFrameHostOwnership();
  96
  97   // IPC::Sender
  98   virtual bool Send(IPC::Message* msg) OVERRIDE;
  99
 100   // IPC::Listener
 101   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
 102
 103   CrossProcessFrameConnector* cross_process_frame_connector() {
 104     return cross_process_frame_connector_.get();
 105   }
 106
 107   // Set the frame's opener to null in the renderer process in response to an
 108   // action in another renderer process.
 109   void DisownOpener();
 110
 111  private:
 112   // This RenderFrameProxyHost's routing id.
 113   int routing_id_;
 114
 115   // The SiteInstance this proxy is associated with.
 116   scoped_refptr<SiteInstance> site_instance_;
 117
 118   // The node in the frame tree where this proxy is located.
 119   FrameTreeNode* frame_tree_node_;
 120
 121   // When a RenderFrameHost is in a different process from its parent in the
 122   // frame tree, this class connects its associated RenderWidgetHostView
 123   // to this RenderFrameProxyHost, which corresponds to the same frame in the
 124   // parent's renderer process.
 125   scoped_ptr<CrossProcessFrameConnector> cross_process_frame_connector_;
 126
 127   // TODO(nasko): This can be removed once we don't have a swapped out state on
 128   // RenderFrameHosts. See https://crbug.com/357747.
 129   scoped_ptr<RenderFrameHostImpl> render_frame_host_;
 130
 131   DISALLOW_COPY_AND_ASSIGN(RenderFrameProxyHost);
 132 };
 133
 134 }  // namespace
 135
 136 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_PROXY_HOST_H_