src/content/renderer/render_frame_proxy.cc

   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
  21 namespace content {
  22
  23 namespace {
  24
  25 // Facilitates lookup of RenderFrameProxy by routing_id.
  26 typedef std::map<int, RenderFrameProxy*> RoutingIDProxyMap;
  27 static base::LazyInstance<RoutingIDProxyMap> g_routing_id_proxy_map =
  28     LAZY_INSTANCE_INITIALIZER;
  29
  30 // Facilitates lookup of RenderFrameProxy by WebFrame.
  31 typedef std::map<blink::WebFrame*, RenderFrameProxy*> FrameMap;
  32 base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
  33
  34 }  // namespace
  35
  36 // static
  37 RenderFrameProxy* 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
  53 RenderFrameProxy* 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
  82 RenderFrameProxy* 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
  89 RenderFrameProxy* 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
  99 RenderFrameProxy::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
 110 RenderFrameProxy::~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
 126 void 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
 142 void RenderFrameProxy::DidCommitCompositorFrame() {
 143   if (compositing_helper_.get())
 144     compositing_helper_->DidCommitCompositorFrame();
 145 }
 146
 147 bool 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
 167 bool 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
 176 void 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
 186 void RenderFrameProxy::OnChildFrameProcessGone() {
 187   if (compositing_helper_.get())
 188     compositing_helper_->ChildFrameGone();
 189 }
 190
 191 void 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
 211 void 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
 232 void 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
 274 void 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