Replacing SurfaceReferenceBase and SequenceSurfaceReference with Closures

cc/surfaces/sequence_surface_reference_factory.cc

Index: cc/surfaces/sequence_surface_reference_factory.cc
diff --git a/cc/surfaces/sequence_surface_reference_factory.cc b/cc/surfaces/sequence_surface_reference_factory.cc
index 3d5b6e25627455e308754504b1d68bec4aafd518..f9b2a4fa9e998ef10778fbed60b0d2c5f7222032 100644
--- a/cc/surfaces/sequence_surface_reference_factory.cc
+++ b/cc/surfaces/sequence_surface_reference_factory.cc
@@ -5,27 +5,26 @@
 #include "cc/surfaces/sequence_surface_reference_factory.h"
 
 #include "base/memory/ptr_util.h"
-#include "cc/surfaces/sequence_surface_reference.h"
+#include "cc/surfaces/scoped_surface_sequence.h"
 
 namespace cc {
 
-std::unique_ptr<SurfaceReferenceBase>
+std::unique_ptr<ScopedSurfaceReferenceBase>
 SequenceSurfaceReferenceFactory::CreateReference(
     SurfaceReferenceOwner* owner,
     const SurfaceId& surface_id) const {
   auto seq = owner->GetSurfaceSequenceGenerator()->CreateSurfaceSequence();
   RequireSequence(surface_id, seq);
-  return base::MakeUnique<SequenceSurfaceReference>(make_scoped_refptr(this),
-                                                    seq);
+  return base::MakeUnique<ScopedSurfaceSequence>(make_scoped_refptr(this), seq);

[danakj, 2017/01/10 16:46:30]

Do the references have to control the lifetime of the factory? Under what
conditions is the factory destroyed before the references?

[Fady Samuel, 2017/01/10 18:14:01]

The references are held on the compositor thread whereas the factory lives on
the main thread so during tear down the factory may be destroyed before the
reference IIRC.

[danakj, 2017/01/10 18:22:02]

What if they are posted to the main thread via
https://cs.chromium.org/chromium/src/cc/trees/blocking_task_runner.h?q=blocki...
BlockingTaskRunner, and we had a BlockingTaskRunner::CapturePostTasks  around
the blocking call to Stop() the compositor thread?

 }
 
 void SequenceSurfaceReferenceFactory::DestroyReference(
-    SurfaceReferenceBase* surface_ref) const {
+    ScopedSurfaceReferenceBase* surface_ref) const {
   // This method can only be called by a SurfaceReferenceBase because it's
   // private and only SurfaceReferenceBase is a friend. The reference only
   // calls this method on the factory that created it. So it's safe to cast
   // the passed reference to the type returned by CreateReference.
-  auto ref = static_cast<SequenceSurfaceReference*>(surface_ref);
+  auto ref = static_cast<ScopedSurfaceSequence*>(surface_ref);
   SatisfySequence(ref->sequence());
 }