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),
+      ack_pending_count_(0),
       frame_connector_(NULL) {
+#if !defined(OS_ANDROID)
+  if (use_surfaces_) {
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    id_allocator_ = factory->GetContextFactory()->CreateSurfaceIdAllocator();
+  }
+#endif  // !defined(OS_ANDROID)
+
   host_->SetView(this);
 }
 
 RenderWidgetHostViewChildFrame::~RenderWidgetHostViewChildFrame() {

[ncarter (slow), 2015/05/28 22:32:52]

If there are still entries in surface_returned_resources_ at this point (because
the RWHVCF is going away while we still have an ack pending) is it possible that
we'd be leaking something in the child process?

Or does surface_factory_->Destroy take care of that?

[kenrb, 2015/05/29 19:29:36]

John answered this separately, but yes: RWHVCF being destroyed means the
RenderWidget and the RenderWidgetCompositor in the renderer are being destroyed,
so resources will be released.

+  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 145 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;
+  DCHECK(ack_pending_count_ > 0);
+  if (!surface_returned_resources_.empty())
+    ack.resources.swap(surface_returned_resources_);
+  if (host_)

[nasko, 2015/05/28 20:42:36]

nit: Two line body requires {}.

[kenrb, 2015/05/29 19:29:36]

Done.

+    host_->Send(new ViewMsg_SwapCompositorFrameAck(host_->GetRoutingID(),
+                                                   output_surface_id, ack));
+  ack_pending_count_--;
+}
+
 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;
   }
+
+#if !defined(OS_ANDROID)
+  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;
+
+  // 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_ && surface_factory_) {
+    surface_factory_->Destroy(surface_id_);
+    surface_factory_.reset();

[ncarter (slow), 2015/05/28 22:32:52]

Why do we need a new SurfaceFactory each time the output surface id changes?

[kenrb, 2015/05/29 19:29:36]

Answered.

+  }
+  if (output_surface_id != last_output_surface_id_ ||
+      frame_size != current_surface_size_ ||
+      scale_factor != current_surface_scale_factor_) {
+    if (surface_factory_ && !surface_id_.is_null())
+      surface_factory_->Destroy(surface_id_);
+    surface_id_ = cc::SurfaceId();
+    last_output_surface_id_ = output_surface_id;
+    current_surface_size_ = frame_size;
+    current_surface_scale_factor_ = scale_factor;
+  }
+
+  if (!surface_factory_) {
+    ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+    cc::SurfaceManager* manager = factory->GetSurfaceManager();
+    surface_factory_ = make_scoped_ptr(new cc::SurfaceFactory(manager, this));
+  }
+
+  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

[nasko, 2015/05/28 20:42:36]

nit: s/renderer/renderer process/?

[kenrb, 2015/05/29 19:29:36]

Done.

+    // SurfaceLayer.
+    factory->GetSurfaceManager()
+        ->GetSurfaceForId(surface_id_)
+        ->AddDestructionDependency(sequence);
+    frame_connector_->SetChildFrameSurface(surface_id_, frame_size,
+                                           scale_factor, sequence);
+  }
+
+  cc::SurfaceFactory::DrawCallback ack_callback =
+      base::Bind(&RenderWidgetHostViewChildFrame::SurfaceDrawn, AsWeakPtr(),
+                 output_surface_id);
+  ack_pending_count_++;

[ncarter (slow), 2015/05/28 22:32:52]

Could we dcheck some upper limit for ack_pending_count_ (the idea being that
getting more than a few frames ahead is madness anyhow, and such a check might
detect a bug where our increments and decrements don't balance out?)

[kenrb, 2015/05/29 19:29:36]

That's a good idea. I don't really know what a safe threshold would be, but I
would expect 1000 to indicate a bug somewhere.

+  surface_factory_->SubmitFrame(surface_id_, frame.Pass(), ack_callback);
+#endif  // !defined(OS_ANDROID)
 }
 
 void RenderWidgetHostViewChildFrame::GetScreenInfo(
     blink::WebScreenInfo* results) {
 }
 
 gfx::Rect RenderWidgetHostViewChildFrame::GetBoundsInRootWindow() {
   // We do not have any root window specific parts in this view.
   return GetViewBounds();
 }
 
 #if defined(USE_AURA)
 void RenderWidgetHostViewChildFrame::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch,
     InputEventAckState ack_result) {
 }
 #endif  // defined(USE_AURA)
 
 bool RenderWidgetHostViewChildFrame::LockMouse() {
   return false;
 }
 
 void RenderWidgetHostViewChildFrame::UnlockMouse() {
 }
 
 uint32_t RenderWidgetHostViewChildFrame::GetSurfaceIdNamespace() {
-  // TODO(kenrb): Create SurfaceFactory here when RWHVChildFrame
-  // gets compositor surface support.
-  return 0;
+  if (!use_surfaces_)
+    return 0;
+
+  return id_allocator_->id_namespace();
 }
 
 #if defined(OS_MACOSX)
 void RenderWidgetHostViewChildFrame::SetActive(bool active) {
 }
 
 void RenderWidgetHostViewChildFrame::SetWindowVisibility(bool visible) {
 }
 
 void RenderWidgetHostViewChildFrame::WindowFrameChanged() {
@@ skipping 55 matching lines @@
 void RenderWidgetHostViewChildFrame::SetParentNativeViewAccessible(
     gfx::NativeViewAccessible accessible_parent) {
 }
 
 gfx::NativeViewId RenderWidgetHostViewChildFrame::GetParentForWindowlessPlugin()
     const {
   return NULL;
 }
 #endif // defined(OS_WIN)
 
+// cc::SurfaceFactoryClient implementation.
+void RenderWidgetHostViewChildFrame::ReturnResources(
+    const cc::ReturnedResourceArray& resources) {
+  if (resources.empty())
+    return;
+
+  if (!ack_pending_count_ && host_) {
+    cc::CompositorFrameAck ack;
+    std::copy(resources.begin(), resources.end(),
+              std::back_inserter(ack.resources));
+    host_->Send(new ViewMsg_ReclaimCompositorResources(
+        host_->GetRoutingID(), last_output_surface_id_, ack));
+    return;
+  }
+
+  std::copy(resources.begin(), resources.end(),
+            std::back_inserter(surface_returned_resources_));
+}
+
 BrowserAccessibilityManager*
 RenderWidgetHostViewChildFrame::CreateBrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate) {
   return BrowserAccessibilityManager::Create(
       BrowserAccessibilityManager::GetEmptyDocument(), delegate);
 }
 
 }  // namespace content