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#include "content/renderer/render_frame_proxy.h"
6
7#include <map>
8
9#include "base/lazy_instance.h"
10#include "content/child/webmessageportchannel_impl.h"
11#include "content/common/frame_messages.h"
12#include "content/common/swapped_out_messages.h"
13#include "content/common/view_messages.h"
14#include "content/renderer/child_frame_compositing_helper.h"
15#include "content/renderer/render_frame_impl.h"
16#include "content/renderer/render_thread_impl.h"
17#include "content/renderer/render_view_impl.h"
18#include "third_party/WebKit/public/web/WebLocalFrame.h"
19#include "third_party/WebKit/public/web/WebView.h"
20
21namespace content {
22
23namespace {
24
25// Facilitates lookup of RenderFrameProxy by routing_id.
26typedef std::map<int, RenderFrameProxy*> RoutingIDProxyMap;
27static base::LazyInstance<RoutingIDProxyMap> g_routing_id_proxy_map =
28    LAZY_INSTANCE_INITIALIZER;
29
30// Facilitates lookup of RenderFrameProxy by WebFrame.
31typedef std::map<blink::WebFrame*, RenderFrameProxy*> FrameMap;
32base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
33
34}  // namespace
35
36// static
37RenderFrameProxy* RenderFrameProxy::CreateProxyToReplaceFrame(
38    RenderFrameImpl* frame_to_replace,
39    int routing_id) {
40  CHECK_NE(routing_id, MSG_ROUTING_NONE);
41
42  scoped_ptr<RenderFrameProxy> proxy(
43      new RenderFrameProxy(routing_id, frame_to_replace->GetRoutingID()));
44
45  // When a RenderFrame is replaced by a RenderProxy, the WebRemoteFrame should
46  // always come from WebRemoteFrame::create and a call to WebFrame::swap must
47  // follow later.
48  blink::WebRemoteFrame* web_frame = blink::WebRemoteFrame::create(proxy.get());
49  proxy->Init(web_frame, frame_to_replace->render_view());
50  return proxy.release();
51}
52
53RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(
54    int routing_id,
55    int parent_routing_id,
56    int render_view_routing_id) {
57  scoped_ptr<RenderFrameProxy> proxy(
58      new RenderFrameProxy(routing_id, MSG_ROUTING_NONE));
59  RenderViewImpl* render_view = NULL;
60  blink::WebRemoteFrame* web_frame = NULL;
61  if (parent_routing_id == MSG_ROUTING_NONE) {
62    // Create a top level frame.
63    render_view = RenderViewImpl::FromRoutingID(render_view_routing_id);
64    web_frame = blink::WebRemoteFrame::create(proxy.get());
65    render_view->webview()->setMainFrame(web_frame);
66  } else {
67    // Create a frame under an existing parent. The parent is always expected
68    // to be a RenderFrameProxy, because navigations initiated by local frames
69    // should not wind up here.
70    RenderFrameProxy* parent =
71        RenderFrameProxy::FromRoutingID(parent_routing_id);
72    web_frame = parent->web_frame()->createRemoteChild("", proxy.get());
73    render_view = parent->render_view();
74  }
75
76  proxy->Init(web_frame, render_view);
77
78  return proxy.release();
79}
80
81// static
82RenderFrameProxy* RenderFrameProxy::FromRoutingID(int32 routing_id) {
83  RoutingIDProxyMap* proxies = g_routing_id_proxy_map.Pointer();
84  RoutingIDProxyMap::iterator it = proxies->find(routing_id);
85  return it == proxies->end() ? NULL : it->second;
86}
87
88// static
89RenderFrameProxy* RenderFrameProxy::FromWebFrame(blink::WebFrame* web_frame) {
90  FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
91  if (iter != g_frame_map.Get().end()) {
92    RenderFrameProxy* proxy = iter->second;
93    DCHECK_EQ(web_frame, proxy->web_frame());
94    return proxy;
95  }
96  return NULL;
97}
98
99RenderFrameProxy::RenderFrameProxy(int routing_id, int frame_routing_id)
100    : routing_id_(routing_id),
101      frame_routing_id_(frame_routing_id),
102      web_frame_(NULL),
103      render_view_(NULL) {
104  std::pair<RoutingIDProxyMap::iterator, bool> result =
105      g_routing_id_proxy_map.Get().insert(std::make_pair(routing_id_, this));
106  CHECK(result.second) << "Inserting a duplicate item.";
107  RenderThread::Get()->AddRoute(routing_id_, this);
108}
109
110RenderFrameProxy::~RenderFrameProxy() {
111  render_view()->UnregisterRenderFrameProxy(this);
112
113  FrameMap::iterator it = g_frame_map.Get().find(web_frame_);
114  CHECK(it != g_frame_map.Get().end());
115  CHECK_EQ(it->second, this);
116  g_frame_map.Get().erase(it);
117
118  RenderThread::Get()->RemoveRoute(routing_id_);
119  g_routing_id_proxy_map.Get().erase(routing_id_);
120
121  // TODO(nick): Call close unconditionally when web_frame() is always remote.
122  if (web_frame()->isWebRemoteFrame())
123    web_frame()->close();
124}
125
126void RenderFrameProxy::Init(blink::WebRemoteFrame* web_frame,
127                            RenderViewImpl* render_view) {
128  CHECK(web_frame);
129  CHECK(render_view);
130
131  web_frame_ = web_frame;
132  render_view_ = render_view;
133
134  // TODO(nick): Should all RenderFrameProxies remain observers of their views?
135  render_view_->RegisterRenderFrameProxy(this);
136
137  std::pair<FrameMap::iterator, bool> result =
138      g_frame_map.Get().insert(std::make_pair(web_frame_, this));
139  CHECK(result.second) << "Inserted a duplicate item.";
140}
141
142void RenderFrameProxy::DidCommitCompositorFrame() {
143  if (compositing_helper_.get())
144    compositing_helper_->DidCommitCompositorFrame();
145}
146
147bool RenderFrameProxy::OnMessageReceived(const IPC::Message& msg) {
148  bool handled = true;
149  IPC_BEGIN_MESSAGE_MAP(RenderFrameProxy, msg)
150    IPC_MESSAGE_HANDLER(FrameMsg_DeleteProxy, OnDeleteProxy)
151    IPC_MESSAGE_HANDLER(FrameMsg_ChildFrameProcessGone, OnChildFrameProcessGone)
152    IPC_MESSAGE_HANDLER_GENERIC(FrameMsg_CompositorFrameSwapped,
153                                OnCompositorFrameSwapped(msg))
154    IPC_MESSAGE_HANDLER(FrameMsg_DisownOpener, OnDisownOpener)
155    IPC_MESSAGE_UNHANDLED(handled = false)
156  IPC_END_MESSAGE_MAP()
157
158  // If |handled| is true, |this| may have been deleted.
159  if (handled)
160    return true;
161
162  RenderFrameImpl* render_frame =
163      RenderFrameImpl::FromRoutingID(frame_routing_id_);
164  return render_frame && render_frame->OnMessageReceived(msg);
165}
166
167bool RenderFrameProxy::Send(IPC::Message* message) {
168  if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
169    delete message;
170    return false;
171  }
172  message->set_routing_id(routing_id_);
173  return RenderThread::Get()->Send(message);
174}
175
176void RenderFrameProxy::OnDeleteProxy() {
177  RenderFrameImpl* render_frame =
178      RenderFrameImpl::FromRoutingID(frame_routing_id_);
179
180  if (render_frame)
181    render_frame->set_render_frame_proxy(NULL);
182
183  delete this;
184}
185
186void RenderFrameProxy::OnChildFrameProcessGone() {
187  if (compositing_helper_.get())
188    compositing_helper_->ChildFrameGone();
189}
190
191void RenderFrameProxy::OnCompositorFrameSwapped(const IPC::Message& message) {
192  FrameMsg_CompositorFrameSwapped::Param param;
193  if (!FrameMsg_CompositorFrameSwapped::Read(&message, &param))
194    return;
195
196  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
197  param.a.frame.AssignTo(frame.get());
198
199  if (!compositing_helper_.get()) {
200    compositing_helper_ =
201        ChildFrameCompositingHelper::CreateForRenderFrameProxy(this);
202    compositing_helper_->EnableCompositing(true);
203  }
204  compositing_helper_->OnCompositorFrameSwapped(frame.Pass(),
205                                                param.a.producing_route_id,
206                                                param.a.output_surface_id,
207                                                param.a.producing_host_id,
208                                                param.a.shared_memory_handle);
209}
210
211void RenderFrameProxy::OnDisownOpener() {
212  // TODO(creis): We should only see this for main frames for now.  To support
213  // disowning the opener on subframes, we will need to move WebContentsImpl's
214  // opener_ to FrameTreeNode.
215  CHECK(!web_frame_->parent());
216
217  // When there is a RenderFrame for this proxy, tell it to disown its opener.
218  // TODO(creis): Remove this when we only have WebRemoteFrames and make sure
219  // they know they have an opener.
220  RenderFrameImpl* render_frame =
221      RenderFrameImpl::FromRoutingID(frame_routing_id_);
222  if (render_frame) {
223    if (render_frame->GetWebFrame()->opener())
224      render_frame->GetWebFrame()->setOpener(NULL);
225    return;
226  }
227
228  if (web_frame_->opener())
229    web_frame_->setOpener(NULL);
230}
231
232void RenderFrameProxy::postMessageEvent(
233    blink::WebLocalFrame* source_frame,
234    blink::WebRemoteFrame* target_frame,
235    blink::WebSecurityOrigin target_origin,
236    blink::WebDOMMessageEvent event) {
237  DCHECK(!web_frame_ || web_frame_ == target_frame);
238
239  ViewMsg_PostMessage_Params params;
240  params.is_data_raw_string = false;
241  params.data = event.data().toString();
242  params.source_origin = event.origin();
243  if (!target_origin.isNull())
244    params.target_origin = target_origin.toString();
245
246  blink::WebMessagePortChannelArray channels = event.releaseChannels();
247  if (!channels.isEmpty()) {
248    std::vector<int> message_port_ids(channels.size());
249     // Extract the port IDs from the channel array.
250     for (size_t i = 0; i < channels.size(); ++i) {
251       WebMessagePortChannelImpl* webchannel =
252           static_cast<WebMessagePortChannelImpl*>(channels[i]);
253       message_port_ids[i] = webchannel->message_port_id();
254       webchannel->QueueMessages();
255       DCHECK_NE(message_port_ids[i], MSG_ROUTING_NONE);
256     }
257     params.message_port_ids = message_port_ids;
258  }
259
260  // Include the routing ID for the source frame (if one exists), which the
261  // browser process will translate into the routing ID for the equivalent
262  // frame in the target process.
263  params.source_routing_id = MSG_ROUTING_NONE;
264  if (source_frame) {
265    RenderViewImpl* source_view =
266        RenderViewImpl::FromWebView(source_frame->view());
267    if (source_view)
268      params.source_routing_id = source_view->routing_id();
269  }
270
271  Send(new ViewHostMsg_RouteMessageEvent(render_view_->GetRoutingID(), params));
272}
273
274void RenderFrameProxy::initializeChildFrame(
275    const blink::WebRect& frame_rect,
276    float scale_factor) {
277  Send(new FrameHostMsg_InitializeChildFrame(
278      routing_id_, frame_rect, scale_factor));
279}
280
281}  // namespace
282