Convert BrowserPlugin to render using cc::Surfaces.

content/renderer/child_frame_compositing_helper.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/child_frame_compositing_helper.h"
 
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/delegated_renderer_layer.h"
@@ skipping 270 matching lines @@
 // static
 void ChildFrameCompositingHelper::RequireCallback(
     scoped_refptr<ThreadSafeSender> sender,
     int host_routing_id,
     cc::SurfaceId id,
     cc::SurfaceSequence sequence) {
   // This may be called on either the main or impl thread.
   sender->Send(new FrameHostMsg_RequireSequence(host_routing_id, id, sequence));
 }
 
+void ChildFrameCompositingHelper::RequireCallbackBrowserPlugin(
+    scoped_refptr<ThreadSafeSender> sender,
+    int host_routing_id,
+    int browser_plugin_instance_id,
+    cc::SurfaceId id,
+    cc::SurfaceSequence sequence) {
+  // This may be called on either the main or impl thread.
+  sender->Send(new BrowserPluginHostMsg_RequireSequence(
+      host_routing_id, browser_plugin_instance_id, id, sequence));
+}
+
 void ChildFrameCompositingHelper::OnSetSurface(
     const cc::SurfaceId& surface_id,
     const gfx::Size& frame_size,
     float scale_factor,
     const cc::SurfaceSequence& sequence) {
   // Surface IDs and compositor frames should never be received
   // interchangably.
   DCHECK(!delegated_layer_.get());
 
   // Do nothing if we are getting destroyed.
   if (!background_layer_.get())
     return;
 
   if (!surface_layer_.get()) {
     scoped_refptr<ThreadSafeSender> sender(
         RenderThreadImpl::current()->thread_safe_sender());
     cc::SurfaceLayer::SatisfyCallback satisfy_callback =
         base::Bind(&ChildFrameCompositingHelper::SatisfyCallback, sender,
                    host_routing_id_);
     cc::SurfaceLayer::RequireCallback require_callback =
-        base::Bind(&ChildFrameCompositingHelper::RequireCallback, sender,
-                   host_routing_id_);
+        render_frame_proxy_
+            ? base::Bind(&ChildFrameCompositingHelper::RequireCallback, sender,
+                         host_routing_id_)
+            : base::Bind(
+                  &ChildFrameCompositingHelper::RequireCallbackBrowserPlugin,
+                  sender, host_routing_id_,
+                  browser_plugin_->browser_plugin_instance_id());
     surface_layer_ =
         cc::SurfaceLayer::Create(cc_blink::WebLayerImpl::LayerSettings(),
                                  satisfy_callback, require_callback);
   }
   surface_layer_->SetSurfaceId(surface_id, scale_factor, frame_size);
   UpdateVisibility(true);
   SetContentsOpaque(opaque_);
   background_layer_->AddChild(surface_layer_);
 
   // The RWHV creates a destruction dependency on the surface that needs to be
-  // satisfied.
-  render_frame_proxy_->Send(
-      new FrameHostMsg_SatisfySequence(host_routing_id_, sequence));
+  // satisfied. Note: render_frame_proxy_ is null in the case our client is a
+  // BrowserPlugin; in this case the BrowserPlugin sends its own SatisfySequence
+  // message.
+  if (render_frame_proxy_) {
+    render_frame_proxy_->Send(
+        new FrameHostMsg_SatisfySequence(host_routing_id_, sequence));
+  } else if (browser_plugin_.get()) {
+    browser_plugin_->SendSatisfySequence(sequence);
+  }
 
   CheckSizeAndAdjustLayerProperties(frame_size, scale_factor,
                                     surface_layer_.get());
 }
 
 void ChildFrameCompositingHelper::UpdateVisibility(bool visible) {
   if (delegated_layer_.get())
     delegated_layer_->SetIsDrawable(visible);
   if (surface_layer_.get())
     surface_layer_->SetIsDrawable(visible);
@@ skipping 21 matching lines @@
 
 void ChildFrameCompositingHelper::SetContentsOpaque(bool opaque) {
   opaque_ = opaque;
   if (delegated_layer_.get())
     delegated_layer_->SetContentsOpaque(opaque_);
   if (surface_layer_.get())
     surface_layer_->SetContentsOpaque(opaque_);
 }
 
 }  // namespace content