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