Destroy egl image handles in the end of playback.

content/common/gpu/media/omx_video_decode_accelerator.cc

 // Copyright (c) 2011 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 "content/common/gpu/media/omx_video_decode_accelerator.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/gles2_texture_to_egl_image_translator.h"
@@ skipping 378 matching lines @@
     const std::vector<media::GLESBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   if (!CanFillBuffer()) {
     StopOnError(VIDEODECODERERROR_UNINITIALIZED);
     return;
   }
   CHECK_EQ(output_buffers_at_component_, 0);
   CHECK_EQ(fake_output_buffers_.size(), 0U);
   CHECK_EQ(pictures_.size(), 0U);
 
+  static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (size_t i = 0; i < buffers.size(); ++i) {
+    EGLImageKHR egl_image = texture2eglImage_translator.TranslateToEglImage(
+        egl_display_, egl_context_, buffers[i].texture_id());
     CHECK(pictures_.insert(std::make_pair(
-        buffers[i].id(), OutputPicture(buffers[i], NULL))).second);
+        buffers[i].id(), OutputPicture(buffers[i], NULL, egl_image))).second);
   }
 
   if (pictures_.size() < kNumPictureBuffers)
     return;  // get all the buffers first.
   DCHECK_EQ(pictures_.size(), kNumPictureBuffers);
 
   if (!AllocateOutputBuffers()) {
     LOG(ERROR) << "OMX_AllocateBuffer() Output buffer error";
     StopOnError(VIDEODECODERERROR_MEMFAILURE);
     return;
@@ skipping 288 matching lines @@
     buffer->nInputPortIndex = input_port_;
     buffer->nOffset = 0;
     buffer->nFlags = 0;
     free_input_buffers_.push(buffer);
   }
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::AllocateOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  static Gles2TextureToEglImageTranslator texture2eglImage_translator;
 
   DCHECK(!pictures_.empty());
   gfx::Size decoded_pixel_size(pictures_.begin()->second.gles_buffer.size());
   gfx::Size visible_pixel_size(pictures_.begin()->second.gles_buffer.size());
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     media::GLESBuffer& gles_buffer = it->second.gles_buffer;
     OMX_BUFFERHEADERTYPE** omx_buffer = &it->second.omx_buffer_header;
     DCHECK(!*omx_buffer);
-    void* egl = texture2eglImage_translator.TranslateToEglImage(
-        egl_display_, egl_context_, gles_buffer.texture_id());
     OMX_ERRORTYPE result = OMX_UseEGLImage(
-        component_handle_, omx_buffer, output_port_, &gles_buffer, egl);
+        component_handle_, omx_buffer, output_port_, &gles_buffer,
+        it->second.egl_image);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_UseEGLImage failed with: " << result;
       return false;
     }
     // Here we set a garbage bitstream buffer id, and then overwrite it before
     // passing to PictureReady.
     int garbage_bitstream_buffer_id = -1;
     (*omx_buffer)->pAppPrivate =
         new media::Picture(gles_buffer.id(), garbage_bitstream_buffer_id,
                            decoded_pixel_size, visible_pixel_size);
@@ skipping 16 matching lines @@
       return;
     }
   }
   VLOG(1) << "Input buffers freed.";
 }
 
 void OmxVideoDecodeAccelerator::FreeOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
+  static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
     CHECK(omx_buffer);
     delete reinterpret_cast<media::Picture*>(omx_buffer->pAppPrivate);
     result = OMX_FreeBuffer(component_handle_, output_port_, omx_buffer);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FreeBuffer failed with: " << result;
       StopOnError(VIDEODECODERERROR_INVALIDINPUT);
       return;
     }
+    texture2eglImage_translator.DestroyEglImage(egl_display_,
+                                                it->second.egl_image);
     client_->DismissPictureBuffer(it->first);
   }
   pictures_.clear();
 }
 
 void OmxVideoDecodeAccelerator::OnIndexParamPortDefinitionChanged(int port) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_EQ(port, output_port_);
   DCHECK(!on_port_disable_event_func_);
   on_port_disable_event_func_ =
@@ skipping 273 matching lines @@
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand() failed" << cmd << ":" << result;
     StopOnError(VIDEODECODERERROR_INVALIDINPUT);
     return;
   }
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);