exo::CompositorFrameSinkHolder's release callbacks hold ref

components/exo/compositor_frame_sink_holder.cc

 // Copyright 2016 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 "components/exo/compositor_frame_sink_holder.h"
 
+#include "base/callback_helpers.h"
 #include "cc/resources/returned_resource.h"
 #include "components/exo/surface.h"
 
 namespace exo {
 
 ////////////////////////////////////////////////////////////////////////////////
 // CompositorFrameSinkHolder, public:
 
 CompositorFrameSinkHolder::CompositorFrameSinkHolder(
     Surface* surface,
     std::unique_ptr<CompositorFrameSink> frame_sink,
     cc::mojom::MojoCompositorFrameSinkClientRequest request)
     : surface_(surface),
       frame_sink_(std::move(frame_sink)),
       begin_frame_source_(base::MakeUnique<cc::ExternalBeginFrameSource>(this)),
       binding_(this, std::move(request)),
       weak_factory_(this) {
   surface_->AddSurfaceObserver(this);
 }
 
 bool CompositorFrameSinkHolder::HasReleaseCallbackForResource(
     cc::ResourceId id) {
   return release_callbacks_.find(id) != release_callbacks_.end();
 }
 
 void CompositorFrameSinkHolder::AddResourceReleaseCallback(
     cc::ResourceId id,
     std::unique_ptr<cc::SingleReleaseCallback> callback) {
-  release_callbacks_[id] = std::make_pair(this, std::move(callback));
+  release_callbacks_[id] = std::move(callback);
 }
 
 void CompositorFrameSinkHolder::ActivateFrameCallbacks(
     std::list<FrameCallback>* frame_callbacks) {
   active_frame_callbacks_.splice(active_frame_callbacks_.end(),
                                  *frame_callbacks);
   UpdateNeedsBeginFrame();
 }
 
 void CompositorFrameSinkHolder::CancelFrameCallbacks() {
@@ skipping 27 matching lines @@
 void CompositorFrameSinkHolder::OnBeginFrame(const cc::BeginFrameArgs& args) {
   while (!active_frame_callbacks_.empty()) {
     active_frame_callbacks_.front().Run(args.frame_time);
     active_frame_callbacks_.pop_front();
   }
   begin_frame_source_->OnBeginFrame(args);
 }
 
 void CompositorFrameSinkHolder::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
+  scoped_refptr<CompositorFrameSinkHolder> holder(this);

[reveman, 2016/12/21 20:05:42]

Please remove this and use PostTask instead. Instance being destroyed when a
member function is called is a bad pattern. Better to defer this I think.

[Alex Z., 2016/12/21 21:30:11]

Sorry about this. I forgot to remove the line after changing to
ScopedClosureRunner.

I noticed that after using ScopedClosureRunner, several GamepadTest became
flaky. I'll look into it.

   for (auto& resource : resources) {
     auto it = release_callbacks_.find(resource.id);
     DCHECK(it != release_callbacks_.end());
-    std::unique_ptr<cc::SingleReleaseCallback> callback =
-        std::move(it->second.second);
+    base::ScopedClosureRunner runner(base::Bind(
+        &cc::SingleReleaseCallback::Run, base::Passed(std::move(it->second)),
+        resource.sync_token, resource.lost));
     release_callbacks_.erase(it);
-    callback->Run(resource.sync_token, resource.lost);
   }
 }
 
 void CompositorFrameSinkHolder::WillDrawSurface() {
   if (surface_)
     surface_->WillDraw();
 
   UpdateNeedsBeginFrame();
 }
 
@@ skipping 33 matching lines @@
 
   bool needs_begin_frame = !active_frame_callbacks_.empty();
   if (needs_begin_frame == needs_begin_frame_)
     return;
 
   needs_begin_frame_ = needs_begin_frame;
   OnNeedsBeginFrames(needs_begin_frame_);
 }
 
 }  // namespace exo