Convert BrowserPlugin to render using cc::Surfaces.

content/browser/frame_host/render_widget_host_view_guest.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 "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.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/browser_plugin/browser_plugin_guest.h"
+#include "content/browser/compositor/surface_utils.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/common/view_messages.h"
 #include "content/common/webplugin_geometry.h"
 #include "content/public/common/content_switches.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 179 matching lines @@
     guest_->SetTooltipText(tooltip_text);
 }
 
 void RenderWidgetHostViewGuest::OnSwapCompositorFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   if (!guest_)
     return;
 
   last_scroll_offset_ = frame->metadata.root_scroll_offset;
-  guest_->SwapCompositorFrame(output_surface_id,
-                              host_->GetProcess()->GetID(),
-                              host_->GetRoutingID(),
-                              frame.Pass());
+  // When not using surfaces, the frame just gets proxied to
+  // the guest's renderer to be composited.

[kenrb, 2015/06/10 20:43:39]

It goes to the embedder's renderer, you mean?

[wjmaclean, 2015/06/10 21:05:02]

Oops, yes.

Done.

+  if (!frame->delegated_frame_data || !use_surfaces_) {
+    guest_->SwapCompositorFrame(output_surface_id,
+                                host_->GetProcess()->GetID(),
+                                host_->GetRoutingID(),
+                                frame.Pass());
+  }
+
+  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;
+
+  guest_->UpdateGuestSizeIfNecessary(frame_size, 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();
+  }
+  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_) {
+    cc::SurfaceManager* manager = 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_);
+
+    cc::SurfaceSequence sequence = cc::SurfaceSequence(
+        id_allocator_->id_namespace(), next_surface_sequence_++);
+    // The renderer process will satisfy this dependency when it creates a
+    // SurfaceLayer.
+    cc::SurfaceManager* manager = GetSurfaceManager();
+    manager->GetSurfaceForId(surface_id_)->AddDestructionDependency(sequence);
+    guest_->SetChildFrameSurface(surface_id_, frame_size, scale_factor,
+                                 sequence);
+  }
+
+  cc::SurfaceFactory::DrawCallback ack_callback = base::Bind(
+      &RenderWidgetHostViewChildFrame::SurfaceDrawn,
+      RenderWidgetHostViewChildFrame::AsWeakPtr(), output_surface_id);
+  ack_pending_count_++;
+  // If this value grows very large, something is going wrong.
+  DCHECK(ack_pending_count_ < 1000);
+  surface_factory_->SubmitFrame(surface_id_, frame.Pass(), ack_callback);
 }
 
 bool RenderWidgetHostViewGuest::OnMessageReceived(const IPC::Message& msg) {
   if (!platform_view_) {
     // In theory, we can get here if there's a delay between DestroyGuestView()
     // being called and when our destructor is invoked.
     return false;
   }
 
   return platform_view_->OnMessageReceived(msg);
@@ skipping 159 matching lines @@
 }
 
 void RenderWidgetHostViewGuest::GetScreenInfo(blink::WebScreenInfo* results) {
   if (!guest_)
     return;
   RenderWidgetHostViewBase* embedder_view = GetOwnerRenderWidgetHostView();
   if (embedder_view)
     embedder_view->GetScreenInfo(results);
 }
 
-uint32_t RenderWidgetHostViewGuest::GetSurfaceIdNamespace() {
-  // Compositing surfaces not supported.
-  return 0;
-}
-
 #if defined(OS_MACOSX)
 void RenderWidgetHostViewGuest::SetActive(bool active) {
   platform_view_->SetActive(active);
 }
 
 void RenderWidgetHostViewGuest::SetWindowVisibility(bool visible) {
   platform_view_->SetWindowVisibility(visible);
 }
 
 void RenderWidgetHostViewGuest::WindowFrameChanged() {
@@ skipping 189 matching lines @@
   }
 
   if (blink::WebInputEvent::isGestureEventType(event->type)) {
     host_->ForwardGestureEvent(
         *static_cast<const blink::WebGestureEvent*>(event));
     return;
   }
 }
 
 }  // namespace content