GVD: DestroyTextures() when destroying.

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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 "media/filters/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop.h"
@@ skipping 176 matching lines @@
       base::Bind(status_cb, PIPELINE_OK));
 }
 
 void GpuVideoDecoder::SetVDA(VideoDecodeAccelerator* vda) {
   DCHECK(vda_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!vda_.get());
   vda_.reset(vda);
   weak_vda_ = vda->AsWeakPtr();
 }
 
+void GpuVideoDecoder::DestroyTextures() {
+  // It's safe to delete textures here, as the VDA should be keeping its own

[Ami GONE FROM CHROMIUM, 2012/10/17 00:48:10]

The explanation you give here, in the CL description, and in the linked bug is
all from too low-level a perspective :)

It is safe to DeleteTextures() here because GVD owns the textures, and because
it has already posted the Destroy() to the VDA loop and thus the GPU process. 
Nothing we do here can get to the GPU process before that Destroy message, and
once that Destroy message gets there the VDA must not touch the textures
anymore.

I'd just drop this comment.

+  // references to the textures. This happens commonly via binding them
+  // to EGLImages or XPixmaps, which ups refcounts on textures in the graphics
+  // drivers.
+  for (std::map<int32, PictureBuffer>::iterator it =
+          picture_buffers_in_decoder_.begin();
+          it != picture_buffers_in_decoder_.end(); ++it) {
+    factories_->DeleteTexture(it->second.texture_id());
+  }
+  picture_buffers_in_decoder_.clear();
+}
+
 void GpuVideoDecoder::DestroyVDA() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   VideoDecodeAccelerator* vda ALLOW_UNUSED = vda_.release();
   // Tricky: |this| needs to stay alive until after VDA::Destroy is actually
   // called, not just posted, so we take an artificial ref to |this| and release
   // it as |reply| after VDA::Destroy() returns.
   AddRef();
   vda_loop_proxy_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::Destroy, weak_vda_),
       base::Bind(&GpuVideoDecoder::Release, this));
+
+  DestroyTextures();
 }
 
 void GpuVideoDecoder::Read(const ReadCB& read_cb) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Read, this, read_cb));
     return;
   }
 
   if (error_occured_) {
@@ skipping 303 matching lines @@
     available_shm_segments_[i]->shm->Close();
     delete available_shm_segments_[i];
   }
   available_shm_segments_.clear();
   for (std::map<int32, BufferPair>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     it->second.shm_buffer->shm->Close();
   }
   bitstream_buffers_in_decoder_.clear();
+
+  DestroyTextures();
 }
 
 void GpuVideoDecoder::EnsureDemuxOrDecode() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (demuxer_read_in_progress_)
     return;
   demuxer_read_in_progress_ = true;
   gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &DemuxerStream::Read, demuxer_stream_.get(),
       base::Bind(&GpuVideoDecoder::RequestBufferDecode, this)));
@@ skipping 47 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media