Allow layers to signal that additional sequences are needed before surface destruction

cc/layers/surface_layer.cc

Index: cc/layers/surface_layer.cc
diff --git a/cc/layers/surface_layer.cc b/cc/layers/surface_layer.cc
index ba577a00d58e7abd952b794ed1dd04d8f98640d3..0de51e53bdaf77045f2d36587ae2573f9d37613f 100644
--- a/cc/layers/surface_layer.cc
+++ b/cc/layers/surface_layer.cc
@@ -4,21 +4,57 @@
 
 #include "cc/layers/surface_layer.h"
 
+#include "cc/base/swap_promise.h"
 #include "cc/layers/surface_layer_impl.h"
+#include "cc/surfaces/surface_manager.h"
+#include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
-scoped_refptr<SurfaceLayer> SurfaceLayer::Create() {
-  return make_scoped_refptr(new SurfaceLayer);
+class SatisfySwapPromise : public SwapPromise {
+ public:
+  SatisfySwapPromise(SurfaceSequence sequence,
+                     SurfaceLayer::SatisfyCallback satisfy_callback)
+      : sequence_(sequence), satisfy_callback_(satisfy_callback) {}

[piman, 2014/11/05 00:36:15]

need a virtual destructor.

+
+ private:
+  void DidSwap(CompositorFrameMetadata* metadata) override {

[piman, 2014/11/05 00:36:15]

Can we add a ThreadChecker in constructor/destructor/DidNotSwap? Otherwise we
might call or destruct the callback on the wrong thread (both are bad).

+    metadata->satisfies_sequences.push_back(sequence_.sequence);
+  }
+
+  void DidNotSwap(DidNotSwapReason reason) override {
+    satisfy_callback_.Run(sequence_);
+  }
+  int64 TraceId() const override { return 0; }
+
+  SurfaceSequence sequence_;
+  SurfaceLayer::SatisfyCallback satisfy_callback_;

[piman, 2014/11/05 00:36:15]

nit: DISALLOW_COPY_AND_ASSIGN

+};
+
+scoped_refptr<SurfaceLayer> SurfaceLayer::Create(
+    SatisfyCallback satisfy_callback,
+    RequireCallback require_callback) {
+  return make_scoped_refptr(
+      new SurfaceLayer(satisfy_callback, require_callback));
 }
 
-SurfaceLayer::SurfaceLayer() : Layer() {
+SurfaceLayer::SurfaceLayer(SatisfyCallback satisfy_callback,
+                           RequireCallback require_callback)
+    : Layer(),
+      satisfy_callback_(satisfy_callback),
+      require_callback_(require_callback) {
 }
 
-SurfaceLayer::~SurfaceLayer() {}
+SurfaceLayer::~SurfaceLayer() {
+  DCHECK(!layer_tree_host());
+  DCHECK(destroy_sequence_.is_null());
+}
 
 void SurfaceLayer::SetSurfaceId(SurfaceId surface_id) {
+  SatisfyDestroySequence();
   surface_id_ = surface_id;
+  CreateNewDestroySequence();
+
   UpdateDrawsContent(HasDrawableContent());
   SetNeedsPushProperties();
 }
@@ -31,6 +67,17 @@ bool SurfaceLayer::HasDrawableContent() const {
   return !surface_id_.is_null() && Layer::HasDrawableContent();
 }
 
+void SurfaceLayer::SetLayerTreeHost(LayerTreeHost* host) {
+  if (layer_tree_host() == host) {
+    Layer::SetLayerTreeHost(host);
+    return;
+  }
+
+  SatisfyDestroySequence();
+  Layer::SetLayerTreeHost(host);
+  CreateNewDestroySequence();
+}
+
 void SurfaceLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
   SurfaceLayerImpl* layer_impl = static_cast<SurfaceLayerImpl*>(layer);
@@ -38,4 +85,22 @@ void SurfaceLayer::PushPropertiesTo(LayerImpl* layer) {
   layer_impl->SetSurfaceId(surface_id_);
 }
 
+void SurfaceLayer::CreateNewDestroySequence() {
+  DCHECK(destroy_sequence_.is_null());
+  if (layer_tree_host()) {
+    destroy_sequence_ = layer_tree_host()->CreateSurfaceSequence();
+    require_callback_.Run(surface_id_, destroy_sequence_);
+  }
+}
+
+void SurfaceLayer::SatisfyDestroySequence() {
+  if (!layer_tree_host())
+    return;
+  DCHECK(!destroy_sequence_.is_null());
+  scoped_ptr<SatisfySwapPromise> satisfy(
+      new SatisfySwapPromise(destroy_sequence_, satisfy_callback_));
+  layer_tree_host()->QueueSwapPromise(satisfy.Pass());
+  destroy_sequence_ = SurfaceSequence();
+}
+
 }  // namespace cc