Reenable idle suspension of media elements on Windows.

media/gpu/dxva_video_decode_accelerator_win.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/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 468 matching lines @@
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     const PendingSampleInfo& other) = default;
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
+    const BindGLImageCallback& bind_image_cb,
     const gpu::GpuDriverBugWorkarounds& workarounds,
     const gpu::GpuPreferences& gpu_preferences)
     : client_(NULL),
       dev_manager_reset_token_(0),
       dx11_dev_manager_reset_token_(0),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
+      bind_image_cb_(bind_image_cb),
       codec_(kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       enable_low_latency_(gpu_preferences.enable_low_latency_dxva),
       share_nv12_textures_(gpu_preferences.enable_zero_copy_dxgi_video &&
                            !workarounds.disable_dxgi_zero_copy_video),
       copy_nv12_textures_(gpu_preferences.enable_nv12_dxgi_video &&
                           !workarounds.disable_nv12_dxgi_video),
       use_dx11_(false),
       use_keyed_mutex_(false),
@@ skipping 367 matching lines @@
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
   // Copy the picture buffers provided by the client to the available list,
   // and mark these buffers as available for use.
   for (size_t buffer_index = 0; buffer_index < buffers.size(); ++buffer_index) {
     linked_ptr<DXVAPictureBuffer> picture_buffer =
         DXVAPictureBuffer::Create(*this, buffers[buffer_index], egl_config_);
     RETURN_AND_NOTIFY_ON_FAILURE(picture_buffer.get(),
                                  "Failed to allocate picture buffer",
                                  PLATFORM_FAILURE, );
+    if (bind_image_cb_) {
+      for (uint32_t client_id : buffers[buffer_index].client_texture_ids()) {

[sandersd (OOO until July 31), 2016/11/15 01:40:06]

For people like myself that rarely work with BOUND images, this structure is
surprising (it looks like different textures will end up with the same
contents). Probably worth a comment.

+        bind_image_cb_.Run(client_id, GetTextureTarget(),
+                           picture_buffer->gl_image(), true);
+      }
+    }
 
     bool inserted =
         output_picture_buffers_
             .insert(std::make_pair(buffers[buffer_index].id(), picture_buffer))
             .second;
     DCHECK(inserted);
   }
 
   ProcessPendingSamples();
   if (pending_flush_ || processing_config_changed_) {
@@ skipping 1031 matching lines @@
   if (GetState() != kUninitialized && client_) {
     // When sharing NV12 textures, the client needs to provide 2 texture IDs
     // per picture buffer, 1 for the Y channel and 1 for the UV channels.
     // They're shared to ANGLE using EGL_NV_stream_consumer_gltexture_yuv, so
     // they need to be GL_TEXTURE_EXTERNAL_OES.
     bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
         provide_nv12_textures ? PIXEL_FORMAT_NV12 : PIXEL_FORMAT_UNKNOWN,
         provide_nv12_textures ? 2 : 1, gfx::Size(width, height),
-        provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D);
+        GetTextureTarget());
   }
 }
 
 void DXVAVideoDecodeAccelerator::NotifyPictureReady(
     int picture_buffer_id,
     int input_buffer_id,
     const gfx::ColorSpace& color_space) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   // This task could execute after the decoder has been torn down.
   if (GetState() != kUninitialized && client_) {
@@ skipping 792 matching lines @@
 
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
+uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
+  bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
+  return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
+}
+
 }  // namespace media