Move ownership of ChildFrameCompositingHelper from frame to proxy.

content/renderer/render_frame_proxy.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_frame_proxy.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "content/common/frame_messages.h"
 #include "content/common/swapped_out_messages.h"
+#include "content/renderer/child_frame_compositing_helper.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
+#include "third_party/WebKit/public/web/WebView.h"
 
 namespace content {
 
 namespace {
 
 typedef std::map<int, RenderFrameProxy*> RoutingIDProxyMap;
 static base::LazyInstance<RoutingIDProxyMap> g_routing_id_proxy_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
@@ skipping 16 matching lines @@
 RenderFrameProxy::RenderFrameProxy(int routing_id, int frame_routing_id)
     : routing_id_(routing_id),
       frame_routing_id_(frame_routing_id) {
   std::pair<RoutingIDProxyMap::iterator, bool> result =
     g_routing_id_proxy_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   render_frame_ = RenderFrameImpl::FromRoutingID(frame_routing_id);
   CHECK(render_frame_);
+  render_frame_->render_view()->RegisterRenderFrameProxy(this);
 }
 
 RenderFrameProxy::~RenderFrameProxy() {
+  render_frame_->render_view()->UnregisterRenderFrameProxy(this);
   RenderThread::Get()->RemoveRoute(routing_id_);
   g_routing_id_proxy_map.Get().erase(routing_id_);
 }
 
+blink::WebFrame* RenderFrameProxy::GetWebFrame() {
+  return render_frame_->GetWebFrame();
+}
+
+void RenderFrameProxy::DidCommitCompositorFrame() {
+  if (compositing_helper_)
+    compositing_helper_->DidCommitCompositorFrame();
+}
+
 bool RenderFrameProxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderFrameProxy, msg)
     IPC_MESSAGE_HANDLER(FrameMsg_DeleteProxy, OnDeleteProxy)
+    IPC_MESSAGE_HANDLER(FrameMsg_ChildFrameProcessGone, OnChildFrameProcessGone)
+    IPC_MESSAGE_HANDLER(FrameMsg_BuffersSwapped, OnBuffersSwapped)
+    IPC_MESSAGE_HANDLER_GENERIC(FrameMsg_CompositorFrameSwapped,
+                                OnCompositorFrameSwapped(msg))
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!handled)
     return render_frame_->OnMessageReceived(msg);
 
   return handled;
 }
 
 bool RenderFrameProxy::Send(IPC::Message* message) {
   if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
     delete message;
     return false;
   }
   message->set_routing_id(routing_id_);
   return RenderThread::Get()->Send(message);
 }
 
 void RenderFrameProxy::OnDeleteProxy() {
   RenderFrameImpl* render_frame =
       RenderFrameImpl::FromRoutingID(frame_routing_id_);
   CHECK(render_frame);
   render_frame->set_render_frame_proxy(NULL);
 
   delete this;
 }
 
+void RenderFrameProxy::OnChildFrameProcessGone() {
+  if (compositing_helper_)
+    compositing_helper_->ChildFrameGone();
+}
+
+void RenderFrameProxy::OnBuffersSwapped(
+    const FrameMsg_BuffersSwapped_Params& params) {
+  if (!compositing_helper_.get()) {
+    compositing_helper_ =
+        ChildFrameCompositingHelper::CreateCompositingHelperForRenderFrame(
+            GetWebFrame(), this, routing_id_);
+    compositing_helper_->EnableCompositing(true);
+  }
+  compositing_helper_->OnBuffersSwapped(
+      params.size,
+      params.mailbox,
+      params.gpu_route_id,
+      params.gpu_host_id,
+      render_frame_->render_view()->GetWebView()->deviceScaleFactor());
+}
+
+void RenderFrameProxy::OnCompositorFrameSwapped(const IPC::Message& message) {
+  FrameMsg_CompositorFrameSwapped::Param param;
+  if (!FrameMsg_CompositorFrameSwapped::Read(&message, &param))
+    return;
+
+  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  param.a.frame.AssignTo(frame.get());
+
+  if (!compositing_helper_.get()) {
+    compositing_helper_ =
+        ChildFrameCompositingHelper::CreateCompositingHelperForRenderFrame(
+            GetWebFrame(), this, routing_id_);
+    compositing_helper_->EnableCompositing(true);
+  }
+  compositing_helper_->OnCompositorFrameSwapped(frame.Pass(),
+                                                param.a.producing_route_id,
+                                                param.a.output_surface_id,
+                                                param.a.producing_host_id,
+                                                param.a.shared_memory_handle);
+}
+
 }  // namespace