Prevent CompositingHelper from prematurely Satisfying Surface reference

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 <utility>
 
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/picture_image_layer.h"
@@ skipping 31 matching lines @@
 
 namespace {
 
 class IframeSurfaceReferenceFactory
     : public cc::SequenceSurfaceReferenceFactory {
  public:
   IframeSurfaceReferenceFactory(scoped_refptr<ThreadSafeSender> sender,
                                 int routing_id)
       : sender_(std::move(sender)), routing_id_(routing_id) {}
 
+  void AddPendingSequence(const cc::SurfaceSequence& sequence) {
+    ReleasePendingSequenceIfNecessary();
+    pending_sequence_ = sequence;
+  }
+
  private:
-  ~IframeSurfaceReferenceFactory() override = default;
+  ~IframeSurfaceReferenceFactory() override {
+    ReleasePendingSequenceIfNecessary();
+  }
+
+  void ReleasePendingSequenceIfNecessary() const {
+    if (pending_sequence_.is_valid()) {
+      sender_->Send(
+          new FrameHostMsg_SatisfySequence(routing_id_, pending_sequence_));
+      pending_sequence_ = cc::SurfaceSequence();
+    }
+  }
 
   // cc::SequenceSurfaceReferenceFactory implementation:
   void RequireSequence(const cc::SurfaceId& surface_id,
                        const cc::SurfaceSequence& sequence) const override {
     sender_->Send(
         new FrameHostMsg_RequireSequence(routing_id_, surface_id, sequence));
+    // If there is a temporary reference that was waiting on a new one to be
+    // created, it is now safe to release it.
+    ReleasePendingSequenceIfNecessary();
   }
 
   void SatisfySequence(const cc::SurfaceSequence& sequence) const override {
     sender_->Send(new FrameHostMsg_SatisfySequence(routing_id_, sequence));
   }
 
   const scoped_refptr<ThreadSafeSender> sender_;
+  mutable cc::SurfaceSequence pending_sequence_;
   const int routing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(IframeSurfaceReferenceFactory);
 };
 
 class BrowserPluginSurfaceReferenceFactory
     : public cc::SequenceSurfaceReferenceFactory {
  public:
   BrowserPluginSurfaceReferenceFactory(scoped_refptr<ThreadSafeSender> sender,
                                        int routing_id,
                                        int browser_plugin_instance_id)
       : sender_(std::move(sender)),
         routing_id_(routing_id),
         browser_plugin_instance_id_(browser_plugin_instance_id) {}
 
+  void AddPendingSequence(const cc::SurfaceSequence& sequence) {
+    ReleasePendingSequenceIfNecessary();
+    pending_sequence_ = sequence;
+  }
+
  private:
-  ~BrowserPluginSurfaceReferenceFactory() override = default;
+  ~BrowserPluginSurfaceReferenceFactory() override {
+    ReleasePendingSequenceIfNecessary();
+  }
+
+  void ReleasePendingSequenceIfNecessary() const {
+    if (pending_sequence_.is_valid()) {
+      sender_->Send(new BrowserPluginHostMsg_SatisfySequence(
+          routing_id_, browser_plugin_instance_id_, pending_sequence_));
+      pending_sequence_ = cc::SurfaceSequence();
+    }
+  }
 
   // cc::SequenceSurfaceRefrenceFactory implementation:
   void SatisfySequence(const cc::SurfaceSequence& seq) const override {
     sender_->Send(new BrowserPluginHostMsg_SatisfySequence(
         routing_id_, browser_plugin_instance_id_, seq));
   }
 
   void RequireSequence(const cc::SurfaceId& surface_id,
                        const cc::SurfaceSequence& sequence) const override {
     sender_->Send(new BrowserPluginHostMsg_RequireSequence(
         routing_id_, browser_plugin_instance_id_, surface_id, sequence));
+    // If there is a temporary reference that was waiting on a new one to be
+    // created, it is now safe to release it.
+    ReleasePendingSequenceIfNecessary();
   }
 
   const scoped_refptr<ThreadSafeSender> sender_;
+  mutable cc::SurfaceSequence pending_sequence_;
   const int routing_id_;
   const int browser_plugin_instance_id_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginSurfaceReferenceFactory);
 };
 
 }  // namespace
 
 ChildFrameCompositingHelper*
 ChildFrameCompositingHelper::CreateForBrowserPlugin(
@@ skipping 108 matching lines @@
   float scale_factor = surface_info.device_scale_factor();
   surface_id_ = surface_info.id();
   scoped_refptr<cc::SurfaceLayer> surface_layer =
       cc::SurfaceLayer::Create(surface_reference_factory_);
   // TODO(oshima): This is a stopgap fix so that the compositor does not
   // scaledown the content when 2x frame data is added to 1x parent frame data.
   // Fix this in cc/.
   if (IsUseZoomForDSFEnabled())
     scale_factor = 1.0f;
 
+  // The RWHV creates a destruction dependency on the surface that needs to be
+  // satisfied. The reference factory will satisfy it when a new reference has
+  // been created.
+  if (render_frame_proxy_) {
+    static_cast<IframeSurfaceReferenceFactory*>(
+        surface_reference_factory_.get())
+        ->AddPendingSequence(sequence);
+  } else {
+    static_cast<BrowserPluginSurfaceReferenceFactory*>(
+        surface_reference_factory_.get())
+        ->AddPendingSequence(sequence);
+  }
+
   cc::SurfaceInfo modified_surface_info(surface_info.id(), scale_factor,
                                         surface_info.size_in_pixels());
   surface_layer->SetPrimarySurfaceInfo(modified_surface_info);
   surface_layer->SetFallbackSurfaceInfo(modified_surface_info);
   surface_layer->SetMasksToBounds(true);
   std::unique_ptr<cc_blink::WebLayerImpl> layer(
       new cc_blink::WebLayerImpl(surface_layer));
   // TODO(lfg): Investigate if it's possible to propagate the information about
   // the child surface's opacity. https://crbug.com/629851.
   layer->SetOpaque(false);
   layer->SetContentsOpaqueIsFixed(true);
   UpdateWebLayer(std::move(layer));
 
   UpdateVisibility(true);
 
-  // The RWHV creates a destruction dependency on the surface that needs to be
-  // 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(
       surface_info.size_in_pixels(), surface_info.device_scale_factor(),
       static_cast<cc_blink::WebLayerImpl*>(web_layer_.get())->layer());
 }
 
 void ChildFrameCompositingHelper::UpdateVisibility(bool visible) {
   if (web_layer_)
     web_layer_->SetDrawsContent(visible);
 }
 
 }  // namespace content