Implement aura::Window::CreateCompositorFrameSink()

components/exo/buffer.cc

 // 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.
 
 #include "components/exo/buffer.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stdint.h>
@@ skipping 410 matching lines @@
   // Note: This can fail if GPU acceleration has been disabled.
   scoped_refptr<cc::ContextProvider> context_provider =
       context_factory->SharedMainThreadContextProvider();
   if (!context_provider) {
     DLOG(WARNING) << "Failed to acquire a context provider";
     resource->id = 0;
     resource->size = gfx::Size();
     return false;
   }
 
-  // The reference to the CompositorFrameSinkHolder keeps it alive until a
-  // release callback is received.
-  compositor_frame_sink_holder_ = compositor_frame_sink_holder;
-
   resource->id = resource_id;
   resource->format = cc::RGBA_8888;
   resource->filter = GL_LINEAR;
   resource->size = gpu_memory_buffer_->GetSize();
 
   // Create a new image texture for |gpu_memory_buffer_| with |texture_target_|
   // if one doesn't already exist. The contents of this buffer are copied to
   // |texture| using a call to CopyTexImage.
   if (!contents_texture_) {
     contents_texture_ = base::MakeUnique<Texture>(
@@ skipping 10 matching lines @@
   if (use_zero_copy_) {
     // This binds the latest contents of this buffer to |contents_texture|.
     gpu::SyncToken sync_token = contents_texture->BindTexImage();
     resource->mailbox_holder = gpu::MailboxHolder(contents_texture->mailbox(),
                                                   sync_token, texture_target_);
     resource->is_overlay_candidate = is_overlay_candidate_;
     resource->buffer_format = gpu_memory_buffer_->GetFormat();
 
     // The contents texture will be released when no longer used by the
     // compositor.
-    compositor_frame_sink_holder_->SetResourceReleaseCallback(
+    compositor_frame_sink_holder->SetResourceReleaseCallback(
         resource_id,
         base::Bind(&Buffer::Texture::ReleaseTexImage,
                    base::Unretained(contents_texture),
                    base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
                               base::Passed(&contents_texture_),
                               release_contents_callback_.callback())));
     return true;
   }
 
   // Create a mailbox texture that we copy the buffer contents to.
   if (!texture_) {
     texture_ =
         base::MakeUnique<Texture>(context_factory, context_provider.get());
   }
   Texture* texture = texture_.get();
 
   // Copy the contents of |contents_texture| to |texture| and produce a
   // texture mailbox from the result in |texture|. The contents texture will
   // be released when copy has completed.
   gpu::SyncToken sync_token = contents_texture->CopyTexImage(
       texture, base::Bind(&Buffer::ReleaseContentsTexture, AsWeakPtr(),
                           base::Passed(&contents_texture_),
                           release_contents_callback_.callback()));
   resource->mailbox_holder =
       gpu::MailboxHolder(texture->mailbox(), sync_token, GL_TEXTURE_2D);
   resource->is_overlay_candidate = false;
 
   // The mailbox texture will be released when no longer used by the
   // compositor.
-  compositor_frame_sink_holder_->SetResourceReleaseCallback(
+  compositor_frame_sink_holder->SetResourceReleaseCallback(
       resource_id,
       base::Bind(&Buffer::Texture::Release, base::Unretained(texture),
                  base::Bind(&Buffer::ReleaseTexture, AsWeakPtr(),
                             base::Passed(&texture_))));
   return true;
 }
 
 void Buffer::OnAttach() {
   DLOG_IF(WARNING, attach_count_)
       << "Reattaching a buffer that is already attached to another surface.";
@@ skipping 53 matching lines @@
 
   // Cancel callback to indicate that buffer has been released.
   release_contents_callback_.Cancel();
 
   // Release buffer if not attached to surface.
   if (!attach_count_)
     Release();
 }
 
 }  // namespace exo