Reenable idle suspension of media elements on Windows.

media/gpu/dxva_picture_buffer_win.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 "media/gpu/dxva_picture_buffer_win.h"
 
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
+#include "ui/gl/gl_image.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_binders.h"
 
 namespace media {
 
 namespace {
 
 void LogDXVAError(int line) {
   LOG(ERROR) << "Error in dxva_picture_buffer_win.cc on line " << line;
 }
 
+// These GLImage subclasses are just used to hold references to the underlying
+// image content so it can be destroyed when the textures are.
+class DummyGLImage : public gl::GLImage {
+ public:
+  DummyGLImage(const gfx::Size& size) : size_(size) {}
+
+  // gl::GLImage implementation.
+  gfx::Size GetSize() override { return size_; }
+  unsigned GetInternalFormat() override { return GL_BGRA_EXT; }
+  bool BindTexImage(unsigned target) override { return false; }
+  void ReleaseTexImage(unsigned target) override {}
+  bool CopyTexImage(unsigned target) override { return false; }
+  bool CopyTexSubImage(unsigned target,
+                       const gfx::Point& offset,
+                       const gfx::Rect& rect) override {
+    return false;
+  }
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                            int z_order,
+                            gfx::OverlayTransform transform,
+                            const gfx::Rect& bounds_rect,
+                            const gfx::RectF& crop_rect) override {
+    return false;
+  }
+  void Flush() override {}
+  void OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
+                    uint64_t process_tracing_id,
+                    const std::string& dump_name) override {}
+
+ protected:
+  ~DummyGLImage() override {}
+
+ private:
+  gfx::Size size_;
+};
+
+class GLImagePbuffer : public DummyGLImage {
+ public:
+  GLImagePbuffer(const gfx::Size& size, EGLSurface surface)
+      : DummyGLImage(size), surface_(surface) {}
+
+ private:
+  ~GLImagePbuffer() override {
+    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
+
+    eglReleaseTexImage(egl_display, surface_, EGL_BACK_BUFFER);
+
+    eglDestroySurface(egl_display, surface_);
+  }
+
+  EGLSurface surface_;
+};
+
+class GLImageEGLStream : public DummyGLImage {
+ public:
+  GLImageEGLStream(const gfx::Size& size, EGLStreamKHR stream)
+      : DummyGLImage(size), stream_(stream) {}
+
+ private:
+  ~GLImageEGLStream() override {
+    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
+    eglDestroyStreamKHR(egl_display, stream_);
+  }
+
+  EGLStreamKHR stream_;
+};
+
 }  // namespace
 
 #define RETURN_ON_FAILURE(result, log, ret) \
   do {                                      \
     if (!(result)) {                        \
       DLOG(ERROR) << log;                   \
       LogDXVAError(__LINE__);               \
       return ret;                           \
     }                                       \
   } while (0)
@@ skipping 97 matching lines @@
                           EGL_TEXTURE_FORMAT,
                           use_rgb ? EGL_TEXTURE_RGB : EGL_TEXTURE_RGBA,
                           EGL_TEXTURE_TARGET,
                           EGL_TEXTURE_2D,
                           EGL_NONE};
 
   decoding_surface_ = eglCreatePbufferFromClientBuffer(
       egl_display, EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE, texture_share_handle_,
       egl_config, attrib_list);
   RETURN_ON_FAILURE(decoding_surface_, "Failed to create surface", false);
+  gl_image_ = make_scoped_refptr(new GLImagePbuffer(size(), decoding_surface_));
   if (decoder.d3d11_device_ && decoder.use_keyed_mutex_) {
     void* keyed_mutex = nullptr;
     EGLBoolean ret =
         eglQuerySurfacePointerANGLE(egl_display, decoding_surface_,
                                     EGL_DXGI_KEYED_MUTEX_ANGLE, &keyed_mutex);
     RETURN_ON_FAILURE(keyed_mutex && ret == EGL_TRUE,
                       "Failed to query ANGLE keyed mutex", false);
     egl_keyed_mutex_ = base::win::ScopedComPtr<IDXGIKeyedMutex>(
         static_cast<IDXGIKeyedMutex*>(keyed_mutex));
   }
@@ skipping 155 matching lines @@
 }
 
 PbufferPictureBuffer::PbufferPictureBuffer(const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer),
       decoding_surface_(NULL),
       texture_share_handle_(nullptr),
       keyed_mutex_value_(0),
       use_rgb_(true) {}
 
 PbufferPictureBuffer::~PbufferPictureBuffer() {
-  if (decoding_surface_) {
-    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
-
-    eglReleaseTexImage(egl_display, decoding_surface_, EGL_BACK_BUFFER);
-
-    eglDestroySurface(egl_display, decoding_surface_);
-    decoding_surface_ = NULL;
-  }
+  // decoding_surface_ will be deleted by gl_image_.
 }
 
 bool PbufferPictureBuffer::ReusePictureBuffer() {
   DCHECK_NE(UNUSED, state_);
   DCHECK(decoding_surface_);
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   eglReleaseTexImage(egl_display, decoding_surface_, EGL_BACK_BUFFER);
 
   decoder_surface_.Release();
   target_surface_.Release();
   decoder_dx11_texture_.Release();
   state_ = UNUSED;
   if (egl_keyed_mutex_) {
     HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
     RETURN_ON_FAILURE(hr == S_OK, "Could not release sync mutex", false);
   }
   return true;
 }
 
 EGLStreamPictureBuffer::EGLStreamPictureBuffer(const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer), stream_(nullptr) {}
 
 EGLStreamPictureBuffer::~EGLStreamPictureBuffer() {
-  if (stream_) {
-    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
-    eglDestroyStreamKHR(egl_display, stream_);
-    stream_ = nullptr;
-  }
+  // stream_ will be deleted by gl_image_.
 }
 
 bool EGLStreamPictureBuffer::Initialize() {
   RETURN_ON_FAILURE(picture_buffer_.service_texture_ids().size() >= 2,
                     "Not enough texture ids provided", false);
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   const EGLint stream_attributes[] = {
       EGL_CONSUMER_LATENCY_USEC_KHR,
       0,
       EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR,
       0,
       EGL_NONE,
   };
   stream_ = eglCreateStreamKHR(egl_display, stream_attributes);
   RETURN_ON_FAILURE(!!stream_, "Could not create stream", false);
+  gl_image_ = make_scoped_refptr(new GLImageEGLStream(size(), stream_));
   gl::ScopedActiveTexture texture0(GL_TEXTURE0);
   gl::ScopedTextureBinder texture0_binder(
       GL_TEXTURE_EXTERNAL_OES, picture_buffer_.service_texture_ids()[0]);
   gl::ScopedActiveTexture texture1(GL_TEXTURE1);
   gl::ScopedTextureBinder texture1_binder(
       GL_TEXTURE_EXTERNAL_OES, picture_buffer_.service_texture_ids()[1]);
 
   EGLAttrib consumer_attributes[] = {
       EGL_COLOR_BUFFER_TYPE,
       EGL_YUV_BUFFER_EXT,
@@ skipping 68 matching lines @@
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
   return true;
 }
 
 EGLStreamCopyPictureBuffer::EGLStreamCopyPictureBuffer(
     const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer), stream_(nullptr) {}
 
 EGLStreamCopyPictureBuffer::~EGLStreamCopyPictureBuffer() {
-  if (stream_) {
-    EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
-    eglDestroyStreamKHR(egl_display, stream_);
-    stream_ = nullptr;
-  }
+  // stream_ will be deleted by gl_image_.
 }
 
 bool EGLStreamCopyPictureBuffer::Initialize(
     const DXVAVideoDecodeAccelerator& decoder) {
   RETURN_ON_FAILURE(picture_buffer_.service_texture_ids().size() >= 2,
                     "Not enough texture ids provided", false);
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   const EGLint stream_attributes[] = {
       EGL_CONSUMER_LATENCY_USEC_KHR,
       0,
       EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR,
       0,
       EGL_NONE,
   };
   stream_ = eglCreateStreamKHR(egl_display, stream_attributes);
   RETURN_ON_FAILURE(!!stream_, "Could not create stream", false);
+  gl_image_ = make_scoped_refptr(new GLImageEGLStream(size(), stream_));
   gl::ScopedActiveTexture texture0(GL_TEXTURE0);
   gl::ScopedTextureBinder texture0_binder(
       GL_TEXTURE_EXTERNAL_OES, picture_buffer_.service_texture_ids()[0]);
   gl::ScopedActiveTexture texture1(GL_TEXTURE1);
   gl::ScopedTextureBinder texture1_binder(
       GL_TEXTURE_EXTERNAL_OES, picture_buffer_.service_texture_ids()[1]);
 
   EGLAttrib consumer_attributes[] = {
       EGL_COLOR_BUFFER_TYPE,
       EGL_YUV_BUFFER_EXT,
@@ skipping 115 matching lines @@
   state_ = UNUSED;
 
   if (stream_) {
     EGLBoolean result = eglStreamConsumerReleaseKHR(egl_display, stream_);
     RETURN_ON_FAILURE(result, "Could not release stream", false);
   }
   return true;
 }
 
 }  // namespace media