exo::CompositorFrameSinkHolder's release callbacks hold ref

components/exo/buffer.h

 // Copyright 2015 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.
 
 #ifndef COMPONENTS_EXO_BUFFER_H_
 #define COMPONENTS_EXO_BUFFER_H_
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "cc/resources/transferable_resource.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
-namespace cc {
-class SingleReleaseCallback;
-class TextureMailbox;
-}
-
 namespace gfx {
 class GpuMemoryBuffer;
 }
 
 namespace exo {
 
+class CompositorFrameSinkHolder;
+
 // This class provides the content for a Surface. The mechanism by which a
 // client provides and updates the contents is the responsibility of the client
 // and not defined as part of this class.
 class Buffer : public base::SupportsWeakPtr<Buffer> {
  public:
   explicit Buffer(std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer);
   Buffer(std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer,
          unsigned texture_target,
          unsigned query_type,
          bool use_zero_copy,
          bool is_overlay_candidate);
   ~Buffer();
 
   // Set the callback to run when the buffer is no longer used by the
   // compositor. The client is free to re-use or destroy this buffer and
   // its backing storage after this has been called.
   void set_release_callback(const base::Closure& release_callback) {
     release_callback_ = release_callback;
   }
 
   // This function can be used to acquire a texture mailbox for the contents of
   // buffer. Returns a release callback on success. The release callback should
   // be called before a new texture mailbox can be acquired unless
   // |non_client_usage| is true.
-  std::unique_ptr<cc::SingleReleaseCallback> ProduceTextureMailbox(
-      cc::TextureMailbox* mailbox,
+  bool ProduceTransferableResource(
+      CompositorFrameSinkHolder* compositor_frame_sink_holder,
+      cc::ResourceId resource_id,
       bool secure_output_only,
-      bool client_usage);
+      bool client_usage,
+      cc::TransferableResource* resource);
 
   // This should be called when the buffer is attached to a Surface.
   void OnAttach();
 
   // This should be called when the buffer is detached from a surface.
   void OnDetach();
 
   // Returns the size of the buffer.
   gfx::Size GetSize() const;
 
@@ skipping 46 matching lines @@
   // instead of creating a new texture when possible.
   std::unique_ptr<Texture> texture_;
 
   // The last used contents texture. ProduceTextureMailbox() will use this
   // instead of creating a new texture when possible.
   std::unique_ptr<Texture> contents_texture_;
 
   // The client release callback.
   base::Closure release_callback_;
 
+  // The CompositorFrameSinkHolder that has the ReleaseCallback of this buffer
+  // produced in ProduceTextureMailbox().
+  // Buffer holds a reference to the CompositorFrameSinkHolder to keep it alive.
+  // The refptr is reset when the release callback is called.
+  scoped_refptr<CompositorFrameSinkHolder> compositor_frame_sink_holder_;
+
   DISALLOW_COPY_AND_ASSIGN(Buffer);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_BUFFER_H_