Allow out-of-process iframes to render to compositing surfaces.

content/browser/frame_host/render_widget_host_view_child_frame.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/browser/frame_host/render_widget_host_view_child_frame.h"
 
+#include "cc/surfaces/surface.h"
+#include "cc/surfaces/surface_factory.h"
+#include "cc/surfaces/surface_manager.h"
+#include "cc/surfaces/surface_sequence.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/frame_host/cross_process_frame_connector.h"
+#include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/render_process_host.h"
 
 namespace content {
 
 RenderWidgetHostViewChildFrame::RenderWidgetHostViewChildFrame(
     RenderWidgetHost* widget_host)
     : host_(RenderWidgetHostImpl::From(widget_host)),
+      use_surfaces_(UseSurfacesEnabled()),
+      next_surface_sequence_(1u),
+      last_output_surface_id_(0),
+      current_surface_scale_factor_(1.f),
       frame_connector_(NULL) {
   host_->SetView(this);
 }
 
 RenderWidgetHostViewChildFrame::~RenderWidgetHostViewChildFrame() {
+  if (!surface_id_.is_null())
+    surface_factory_->Destroy(surface_id_);
 }
 
 void RenderWidgetHostViewChildFrame::InitAsChild(
     gfx::NativeView parent_view) {
   NOTREACHED();
 }
 
 RenderWidgetHost* RenderWidgetHostViewChildFrame::GetRenderWidgetHost() const {
   return host_;
 }
@@ skipping 148 matching lines @@
 }
 
 #if defined(OS_ANDROID)
 void RenderWidgetHostViewChildFrame::LockCompositingSurface() {
 }
 
 void RenderWidgetHostViewChildFrame::UnlockCompositingSurface() {
 }
 #endif
 
+void RenderWidgetHostViewChildFrame::SurfaceDrawn(uint32 output_surface_id,
+                                                  cc::SurfaceDrawStatus drawn) {
+  cc::CompositorFrameAck ack;
+  host_->Send(new ViewMsg_SwapCompositorFrameAck(host_->GetRoutingID(),
+                                                 output_surface_id, ack));
+}
+
 void RenderWidgetHostViewChildFrame::OnSwapCompositorFrame(
       uint32 output_surface_id,
       scoped_ptr<cc::CompositorFrame> frame) {
   last_scroll_offset_ = frame->metadata.root_scroll_offset;
-  if (frame_connector_) {
+
+  if (!frame_connector_)
+    return;
+
+  // When not using surfaces, the frame just gets proxied to
+  // the embedder's renderer to be composited.
+  if (!frame->delegated_frame_data || !use_surfaces_) {
     frame_connector_->ChildFrameCompositorFrameSwapped(
         output_surface_id,
         host_->GetProcess()->GetID(),
         host_->GetRoutingID(),
         frame.Pass());
+    return;
   }
+
+  cc::RenderPass* root_pass =
+      frame->delegated_frame_data->render_pass_list.back();
+
+  gfx::Size frame_size = root_pass->output_rect.size();
+  float scale_factor = frame->metadata.device_scale_factor;
+
+  if (!surface_factory_) {
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    cc::SurfaceManager* manager = factory->GetSurfaceManager();
+    id_allocator_ = factory->GetContextFactory()->CreateSurfaceIdAllocator();
+    surface_factory_ = make_scoped_ptr(new cc::SurfaceFactory(manager, this));
+  }
+
+  // Check whether we need to recreate the cc::Surface, which means the child
+  // frame renderer has changed its output surface, or size, or scale factor.
+  if (output_surface_id != last_output_surface_id_ ||
+      frame_size != current_surface_size_ ||
+      scale_factor != current_surface_scale_factor_) {
+    if (!surface_id_.is_null()) {
+      surface_factory_->Destroy(surface_id_);
+      surface_id_ = cc::SurfaceId();
+      surface_factory_.reset();
+    }
+    last_output_surface_id_ = output_surface_id;
+    current_surface_size_ = frame_size;
+    current_surface_scale_factor_ = scale_factor;
+  }
+
+  if (surface_id_.is_null()) {
+    surface_id_ = id_allocator_->GenerateId();
+    surface_factory_->Create(surface_id_);
+
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    cc::SurfaceSequence sequence = cc::SurfaceSequence(
+        id_allocator_->id_namespace(), next_surface_sequence_++);
+    // The renderer will satisfy this dependency when it creates a
+    // SurfaceLayer.
+    factory->GetSurfaceManager()
+        ->GetSurfaceForId(surface_id_)
+        ->AddDestructionDependency(sequence);

[jbauman, 2015/05/01 23:58:10]

I guess we'll also need to figure out what happens with surface sequences when
one of these two renderers is destroyed.

[kenrb, 2015/05/05 16:24:37]

I don't entirely understand James' response, but it sounds like we want to do
something from RWHV*::RenderProcessGone. That should probably be a separate CL.

+    frame_connector_->SetChildFrameSurface(surface_id_, frame_size,
+                                           scale_factor, sequence);
+  }
+
+  cc::SurfaceFactory::DrawCallback ack_callback =
+      base::Bind(&RenderWidgetHostViewChildFrame::SurfaceDrawn, AsWeakPtr(),
+                 output_surface_id);
+  surface_factory_->SubmitFrame(surface_id_, frame.Pass(), ack_callback);
 }
 
 void RenderWidgetHostViewChildFrame::GetScreenInfo(
     blink::WebScreenInfo* results) {
 }
 
 gfx::Rect RenderWidgetHostViewChildFrame::GetBoundsInRootWindow() {
   // We do not have any root window specific parts in this view.
   return GetViewBounds();
 }
@@ skipping 82 matching lines @@
 gfx::NativeViewId RenderWidgetHostViewChildFrame::GetParentForWindowlessPlugin()
     const {
   return NULL;
 }
 #endif // defined(OS_WIN)
 
 SkColorType RenderWidgetHostViewChildFrame::PreferredReadbackFormat() {
   return kN32_SkColorType;
 }
 
+// cc::SurfaceFactoryClient implementation.
+void RenderWidgetHostViewChildFrame::ReturnResources(
+    const cc::ReturnedResourceArray& resources) {

[jbauman, 2015/05/01 23:58:10]

This needs to store the resources if there's an ack outstanding (and the ack
needs to send them as well) or otherwise send a reclaim message with them.

[kenrb, 2015/05/05 16:24:38]

Done.

+  // ??
+}
+
 BrowserAccessibilityManager*
 RenderWidgetHostViewChildFrame::CreateBrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate) {
   return BrowserAccessibilityManager::Create(
       BrowserAccessibilityManager::GetEmptyDocument(), delegate);
 }
 
 }  // namespace content