Use IDXGIKeyedMutex to synchronize between DXVA decoder and main context

content/common/gpu/media/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 "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 144 matching lines @@
   // Maximum number of iterations we allow before aborting the attempt to flush
   // the batched queries to the driver and allow torn/corrupt frames to be
   // rendered.
   kFlushDecoderSurfaceTimeoutMs = 1,
   // Maximum iterations where we try to flush the d3d device.
   kMaxIterationsForD3DFlush = 4,
   // We only request 5 picture buffers from the client which are used to hold
   // the decoded samples. These buffers are then reused when the client tells
   // us that it is done with the buffer.
   kNumPictureBuffers = 5,
+  // The keyed mutex should always be released before the other thread
+  // attempts to acquire it, so AcquireSync should always return immediately.
+  kAcquireSyncWaitMs = 0,
 };
 
 static IMFSample* CreateEmptySample() {
   base::win::ScopedComPtr<IMFSample> sample;
   HRESULT hr = MFCreateSample(sample.Receive());
   RETURN_ON_HR_FAILURE(hr, "MFCreateSample failed", NULL);
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer of length |buffer_length|
@@ skipping 163 matching lines @@
 // Maintains information about a DXVA picture buffer, i.e. whether it is
 // available for rendering, the texture information, etc.
 struct DXVAVideoDecodeAccelerator::DXVAPictureBuffer {
  public:
   static linked_ptr<DXVAPictureBuffer> Create(
       const DXVAVideoDecodeAccelerator& decoder,
       const media::PictureBuffer& buffer,
       EGLConfig egl_config);
   ~DXVAPictureBuffer();
 
-  void ReusePictureBuffer();
+  bool ReusePictureBuffer();
   // Copies the output sample data to the picture buffer provided by the
   // client.
   // The dest_surface parameter contains the decoded bits.
   bool CopyOutputSampleDataToPictureBuffer(
       DXVAVideoDecodeAccelerator* decoder,
       IDirect3DSurface9* dest_surface,
       ID3D11Texture2D* dx11_texture,
       int input_buffer_id);
 
   bool available() const {
     return available_;
   }
 
   void set_available(bool available) {
     available_ = available;
   }
 
   int id() const {
     return picture_buffer_.id();
   }
 
   gfx::Size size() const {
     return picture_buffer_.size();
   }
 
   // Called when the source surface |src_surface| is copied to the destination
   // |dest_surface|
-  void CopySurfaceComplete(IDirect3DSurface9* src_surface,
+  bool CopySurfaceComplete(IDirect3DSurface9* src_surface,
                            IDirect3DSurface9* dest_surface);
 
  private:
   explicit DXVAPictureBuffer(const media::PictureBuffer& buffer);
 
   bool available_;
   media::PictureBuffer picture_buffer_;
   EGLSurface decoding_surface_;
   base::win::ScopedComPtr<IDirect3DTexture9> decoding_texture_;
   base::win::ScopedComPtr<ID3D11Texture2D> dx11_decoding_texture_;
 
+  base::win::ScopedComPtr<IDXGIKeyedMutex> egl_keyed_mutex_;
+  base::win::ScopedComPtr<IDXGIKeyedMutex> dx11_keyed_mutex_;
+
+  // This is the last value that was used to release the keyed mutex.
+  uint64_t keyed_mutex_value_;
+
   // The following |IDirect3DSurface9| interface pointers are used to hold
   // references on the surfaces during the course of a StretchRect operation
   // to copy the source surface to the target. The references are released
   // when the StretchRect operation i.e. the copy completes.
   base::win::ScopedComPtr<IDirect3DSurface9> decoder_surface_;
   base::win::ScopedComPtr<IDirect3DSurface9> target_surface_;
 
   // This ID3D11Texture2D interface pointer is used to hold a reference to the
   // decoder texture during the course of a copy operation. This reference is
   // released when the copy completes.
@@ skipping 13 matching lines @@
     const media::PictureBuffer& buffer,
     EGLConfig egl_config) {
   linked_ptr<DXVAPictureBuffer> picture_buffer(new DXVAPictureBuffer(buffer));
 
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
 
   EGLint use_rgb = 1;
   eglGetConfigAttrib(egl_display, egl_config, EGL_BIND_TO_TEXTURE_RGB,
                      &use_rgb);
 
+  HANDLE share_handle = nullptr;
+  if (decoder.d3d11_device_) {

[ananta, 2016/01/22 00:40:18]

Please update the patch description to reflect that with this patch we are
creating the texture and sharing it with ANGLE instead of the other way around.

It would be great if you could move the texture creation into a separate
function to make this easier to read.

+    D3D11_TEXTURE2D_DESC desc;
+    desc.Width = buffer.size().width();
+    desc.Height = buffer.size().height();
+    desc.MipLevels = 1;
+    desc.ArraySize = 1;
+    desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+    desc.SampleDesc.Count = 1;
+    desc.SampleDesc.Quality = 0;
+    desc.Usage = D3D11_USAGE_DEFAULT;
+    desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;
+    desc.CPUAccessFlags = 0;
+    desc.MiscFlags = decoder.use_keyed_mutex_
+                         ? D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX
+                         : D3D11_RESOURCE_MISC_SHARED;
+
+    HRESULT hr = decoder.d3d11_device_->CreateTexture2D(
+        &desc, nullptr, picture_buffer->dx11_decoding_texture_.Receive());
+    RETURN_ON_HR_FAILURE(hr, "Failed to create texture",
+                         linked_ptr<DXVAPictureBuffer>(nullptr));
+    if (decoder.use_keyed_mutex_) {
+      hr = picture_buffer->dx11_keyed_mutex_.QueryFrom(
+          picture_buffer->dx11_decoding_texture_.get());
+      RETURN_ON_HR_FAILURE(hr, "Failed to get keyed mutex",
+                           linked_ptr<DXVAPictureBuffer>(nullptr));
+    }
+
+    base::win::ScopedComPtr<IDXGIResource> resource;
+    hr = resource.QueryFrom(picture_buffer->dx11_decoding_texture_.get());
+    DCHECK(SUCCEEDED(hr));
+    hr = resource->GetSharedHandle(&share_handle);
+    RETURN_ON_FAILURE(SUCCEEDED(hr) && share_handle,
+                      "Failed to query shared handle",
+                      linked_ptr<DXVAPictureBuffer>(nullptr));
+
+  } else {
+    HRESULT hr = E_FAIL;
+    hr = decoder.d3d9_device_ex_->CreateTexture(
+        buffer.size().width(), buffer.size().height(), 1, D3DUSAGE_RENDERTARGET,
+        use_rgb ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
+        picture_buffer->decoding_texture_.Receive(), &share_handle);
+    RETURN_ON_HR_FAILURE(hr, "Failed to create texture",
+                         linked_ptr<DXVAPictureBuffer>(nullptr));
+    RETURN_ON_FAILURE(share_handle, "Failed to query shared handle",
+                      linked_ptr<DXVAPictureBuffer>(nullptr));
+  }
+
   EGLint attrib_list[] = {
     EGL_WIDTH, buffer.size().width(),
     EGL_HEIGHT, buffer.size().height(),
     EGL_TEXTURE_FORMAT, use_rgb ? EGL_TEXTURE_RGB : EGL_TEXTURE_RGBA,
     EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
     EGL_NONE
   };
 
-  picture_buffer->decoding_surface_ = eglCreatePbufferSurface(
-      egl_display,
-      egl_config,
-      attrib_list);
+  picture_buffer->decoding_surface_ = eglCreatePbufferFromClientBuffer(
+      egl_display, EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE, share_handle,
+      egl_config, attrib_list);
   RETURN_ON_FAILURE(picture_buffer->decoding_surface_,
                     "Failed to create surface",
                     linked_ptr<DXVAPictureBuffer>(NULL));
-
-  HANDLE share_handle = NULL;
-  EGLBoolean ret = eglQuerySurfacePointerANGLE(
-      egl_display,
-      picture_buffer->decoding_surface_,
-      EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE,
-      &share_handle);
-
-  RETURN_ON_FAILURE(share_handle && ret == EGL_TRUE,
-                    "Failed to query ANGLE surface pointer",
-                    linked_ptr<DXVAPictureBuffer>(NULL));
-
-  HRESULT hr = E_FAIL;
-  if (decoder.d3d11_device_) {
-    base::win::ScopedComPtr<ID3D11Resource> resource;
-    hr = decoder.d3d11_device_->OpenSharedResource(
-        share_handle,
-        __uuidof(ID3D11Resource),
-        reinterpret_cast<void**>(resource.Receive()));
-    RETURN_ON_HR_FAILURE(hr, "Failed to open shared resource",
-                         linked_ptr<DXVAPictureBuffer>(NULL));
-    hr = picture_buffer->dx11_decoding_texture_.QueryFrom(resource.get());
-  } else {
-    hr = decoder.d3d9_device_ex_->CreateTexture(
-        buffer.size().width(),
-        buffer.size().height(),
-        1,
-        D3DUSAGE_RENDERTARGET,
-        use_rgb ? D3DFMT_X8R8G8B8 : D3DFMT_A8R8G8B8,
-        D3DPOOL_DEFAULT,
-        picture_buffer->decoding_texture_.Receive(),
-        &share_handle);
+  if (decoder.d3d11_device_ && decoder.use_keyed_mutex_) {
+    void* keyed_mutex = nullptr;
+    EGLBoolean ret = eglQuerySurfacePointerANGLE(
+        egl_display, picture_buffer->decoding_surface_,
+        EGL_DXGI_KEYED_MUTEX_ANGLE, &keyed_mutex);
+    RETURN_ON_FAILURE(keyed_mutex && ret == EGL_TRUE,
+                      "Failed to query ANGLE keyed mutex",
+                      linked_ptr<DXVAPictureBuffer>(nullptr));
+    picture_buffer->egl_keyed_mutex_ = base::win::ScopedComPtr<IDXGIKeyedMutex>(
+        static_cast<IDXGIKeyedMutex*>(keyed_mutex));
   }
-  RETURN_ON_HR_FAILURE(hr, "Failed to create texture",
-                       linked_ptr<DXVAPictureBuffer>(NULL));
   picture_buffer->use_rgb_ = !!use_rgb;
   return picture_buffer;
 }
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::DXVAPictureBuffer(
     const media::PictureBuffer& buffer)
     : available_(true),
       picture_buffer_(buffer),
       decoding_surface_(NULL),
-      use_rgb_(true) {
-}
+      keyed_mutex_value_(0),
+      use_rgb_(true) {}
 
 DXVAVideoDecodeAccelerator::DXVAPictureBuffer::~DXVAPictureBuffer() {
   if (decoding_surface_) {
     EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
 
     eglReleaseTexImage(
         egl_display,
         decoding_surface_,
         EGL_BACK_BUFFER);
 
     eglDestroySurface(
         egl_display,
         decoding_surface_);
     decoding_surface_ = NULL;
   }
 }
 
-void DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ReusePictureBuffer() {
+bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer::ReusePictureBuffer() {
   DCHECK(decoding_surface_);
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglReleaseTexImage(
     egl_display,
     decoding_surface_,
     EGL_BACK_BUFFER);
   decoder_surface_.Release();
   target_surface_.Release();
   decoder_dx11_texture_.Release();
   set_available(true);
+  if (egl_keyed_mutex_) {
+    HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
+    if (hr != S_OK)
+      return false;
+  }
+  return true;
 }
 
 bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer::
     CopyOutputSampleDataToPictureBuffer(
         DXVAVideoDecodeAccelerator* decoder,
         IDirect3DSurface9* dest_surface,
         ID3D11Texture2D* dx11_texture,
         int input_buffer_id) {
   DCHECK(dest_surface || dx11_texture);
   if (dx11_texture) {
     // Grab a reference on the decoder texture. This reference will be released
     // when we receive a notification that the copy was completed or when the
     // DXVAPictureBuffer instance is destroyed.
     decoder_dx11_texture_ = dx11_texture;
-    decoder->CopyTexture(dx11_texture, dx11_decoding_texture_.get(), NULL,
-                         id(), input_buffer_id);
+    decoder->CopyTexture(dx11_texture, dx11_decoding_texture_.get(),
+                         dx11_keyed_mutex_, keyed_mutex_value_, NULL, id(),
+                         input_buffer_id);
     return true;
   }
   D3DSURFACE_DESC surface_desc;
   HRESULT hr = dest_surface->GetDesc(&surface_desc);
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
 
   D3DSURFACE_DESC texture_desc;
   decoding_texture_->GetLevelDesc(0, &texture_desc);
 
   if (texture_desc.Width != surface_desc.Width ||
@@ skipping 19 matching lines @@
   hr = decoding_texture_->GetSurfaceLevel(0, target_surface_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false);
 
   decoder_surface_ = dest_surface;
 
   decoder->CopySurface(decoder_surface_.get(), target_surface_.get(), id(),
                        input_buffer_id);
   return true;
 }
 
-void DXVAVideoDecodeAccelerator::DXVAPictureBuffer::CopySurfaceComplete(
+bool DXVAVideoDecodeAccelerator::DXVAPictureBuffer::CopySurfaceComplete(
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface) {
   DCHECK(!available());
 
   GLint current_texture = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
   glBindTexture(GL_TEXTURE_2D, picture_buffer_.texture_id());
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
   if (src_surface && dest_surface) {
     DCHECK_EQ(src_surface, decoder_surface_.get());
     DCHECK_EQ(dest_surface, target_surface_.get());
     decoder_surface_.Release();
     target_surface_.Release();
   } else {
     DCHECK(decoder_dx11_texture_.get());
     decoder_dx11_texture_.Release();
   }
+  if (egl_keyed_mutex_) {
+    keyed_mutex_value_++;
+    HRESULT result =
+        egl_keyed_mutex_->AcquireSync(keyed_mutex_value_, kAcquireSyncWaitMs);
+    if (result != S_OK)
+      return false;
+  }
 
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   eglBindTexImage(
       egl_display,
       decoding_surface_,
       EGL_BACK_BUFFER);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glBindTexture(GL_TEXTURE_2D, current_texture);
+  return true;
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32 buffer_id, IMFSample* sample)
     : input_buffer_id(buffer_id),
       picture_buffer_id(-1) {
   output_sample.Attach(sample);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
@@ skipping 334 matching lines @@
     it = stale_output_picture_buffers_.find(picture_buffer_id);
     RETURN_AND_NOTIFY_ON_FAILURE(it != stale_output_picture_buffers_.end(),
         "Invalid picture id: " << picture_buffer_id, INVALID_ARGUMENT,);
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::DeferredDismissStaleBuffer,
                    weak_this_factory_.GetWeakPtr(), picture_buffer_id));
     return;
   }
 
-  it->second->ReusePictureBuffer();
+  RETURN_AND_NOTIFY_ON_FAILURE(it->second->ReusePictureBuffer(),
+                               "Failed to reuse picture buffer",
+                               PLATFORM_FAILURE, );
+
   ProcessPendingSamples();
   if (pending_flush_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                    base::Unretained(this)));
   }
 }
 
 void DXVAVideoDecodeAccelerator::Flush() {
@@ skipping 256 matching lines @@
   //    this. This should always be true for Windows 8+.
   // 3. ANGLE is using DX11.
   DCHECK(gl_context_);
   if (create_dxgi_device_manager_ &&
       (gl_context_->GetGLRenderer().find("Direct3D11") !=
            std::string::npos)) {
     UINT32 dx11_aware = 0;
     attributes->GetUINT32(MF_SA_D3D11_AWARE, &dx11_aware);
     use_dx11_ = !!dx11_aware;
   }
+
+  use_keyed_mutex_ =
+      use_dx11_ && gfx::GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_keyed_mutex");
+
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderMediaTypes() {
   RETURN_ON_FAILURE(SetDecoderInputMediaType(),
                     "Failed to set decoder input media type", false);
   return SetDecoderOutputMediaType(MFVideoFormat_NV12);
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderInputMediaType() {
@@ skipping 694 matching lines @@
   // was a Reset operation which dropped the output frame.
   DXVAPictureBuffer* picture_buffer = it->second.get();
   if (picture_buffer->available())
     return;
 
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_.Run(),
       "Failed to make context current", PLATFORM_FAILURE,);
 
   DCHECK(!output_picture_buffers_.empty());
 
-  picture_buffer->CopySurfaceComplete(src_surface,
-                                      dest_surface);
+  bool result = picture_buffer->CopySurfaceComplete(src_surface, dest_surface);
+  RETURN_AND_NOTIFY_ON_FAILURE(result, "Failed to complete copying surface",
+                               PLATFORM_FAILURE, );
 
   NotifyPictureReady(picture_buffer->id(), input_buffer_id);
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
       pending_output_samples_.pop_front();
   }
 
   if (pending_flush_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
                    base::Unretained(this)));
     return;
   }
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
-void DXVAVideoDecodeAccelerator::CopyTexture(ID3D11Texture2D* src_texture,
-                                             ID3D11Texture2D* dest_texture,
-                                             IMFSample* video_frame,
-                                             int picture_buffer_id,
-                                             int input_buffer_id) {
+void DXVAVideoDecodeAccelerator::CopyTexture(
+    ID3D11Texture2D* src_texture,
+    ID3D11Texture2D* dest_texture,
+    base::win::ScopedComPtr<IDXGIKeyedMutex> dest_keyed_mutex,
+    uint64_t keyed_mutex_value,
+    IMFSample* video_frame,
+    int picture_buffer_id,
+    int input_buffer_id) {
   HRESULT hr = E_FAIL;
 
   DCHECK(use_dx11_);
 
   if (!decoder_thread_task_runner_->BelongsToCurrentThread()) {
     // The media foundation H.264 decoder outputs YUV12 textures which we
     // cannot copy into ANGLE as they expect ARGB textures. In D3D land
     // the StretchRect API in the IDirect3DDevice9Ex interface did the color
     // space conversion for us. Sadly in DX11 land the API does not provide
     // a straightforward way to do this.
@@ skipping 16 matching lines @@
 
     // The input to the video processor is the output sample.
     base::win::ScopedComPtr<IMFSample> input_sample_for_conversion;
     {
       base::AutoLock lock(decoder_lock_);
       PendingSampleInfo& sample_info = pending_output_samples_.front();
       input_sample_for_conversion = sample_info.output_sample;
     }
 
     decoder_thread_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&DXVAVideoDecodeAccelerator::CopyTexture,
-                    base::Unretained(this),
-                    src_texture,
-                    dest_texture,
-                    input_sample_for_conversion.Detach(),
-                    picture_buffer_id,
-                    input_buffer_id));
+        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::CopyTexture,
+                              base::Unretained(this), src_texture, dest_texture,
+                              dest_keyed_mutex, keyed_mutex_value,
+                              input_sample_for_conversion.Detach(),
+                              picture_buffer_id, input_buffer_id));
     return;
   }
 
   DCHECK(video_frame);
 
   base::win::ScopedComPtr<IMFSample> input_sample;
   input_sample.Attach(video_frame);
 
   DCHECK(video_format_converter_mft_.get());
 
+  if (dest_keyed_mutex) {
+    HRESULT hr =
+        dest_keyed_mutex->AcquireSync(keyed_mutex_value, kAcquireSyncWaitMs);
+    RETURN_AND_NOTIFY_ON_FAILURE(
+        hr == S_OK, "D3D11 failed to acquire keyed mutex for texture.",
+        PLATFORM_FAILURE, );
+  }
   // The video processor MFT requires output samples to be allocated by the
   // caller. We create a sample with a buffer backed with the ID3D11Texture2D
   // interface exposed by ANGLE. This works nicely as this ensures that the
   // video processor coverts the color space of the output frame and copies
   // the result into the ANGLE texture.
   base::win::ScopedComPtr<IMFSample> output_sample;
   hr = MFCreateSample(output_sample.Receive());
   if (FAILED(hr)) {
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
         "Failed to create output sample.", PLATFORM_FAILURE,);
@@ skipping 34 matching lines @@
   if (FAILED(hr)) {
     base::debug::Alias(&hr);
     // TODO(ananta)
     // Remove this CHECK when the change to use DX11 for H/W decoding
     // stablizes.
     CHECK(false);
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
         "Failed to convert output sample format.", PLATFORM_FAILURE,);
   }
 
-  d3d11_device_context_->Flush();
-  d3d11_device_context_->End(d3d11_query_.get());
+  if (dest_keyed_mutex) {
+    HRESULT hr = dest_keyed_mutex->ReleaseSync(keyed_mutex_value + 1);
+    RETURN_AND_NOTIFY_ON_FAILURE(hr == S_OK, "Failed to release keyed mutex.",
+                                 PLATFORM_FAILURE, );
 
-  decoder_thread_task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
-                 base::Unretained(this), 0,
-                 reinterpret_cast<IDirect3DSurface9*>(NULL),
-                 reinterpret_cast<IDirect3DSurface9*>(NULL),
-                 picture_buffer_id, input_buffer_id),
-                 base::TimeDelta::FromMilliseconds(
-                    kFlushDecoderSurfaceTimeoutMs));
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::CopySurfaceComplete,
+                              weak_this_factory_.GetWeakPtr(), nullptr, nullptr,
+                              picture_buffer_id, input_buffer_id));
+  } else {
+    d3d11_device_context_->Flush();
+    d3d11_device_context_->End(d3d11_query_.get());
+
+    decoder_thread_task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
+                              base::Unretained(this), 0,
+                              reinterpret_cast<IDirect3DSurface9*>(NULL),
+                              reinterpret_cast<IDirect3DSurface9*>(NULL),
+                              picture_buffer_id, input_buffer_id),
+        base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
+  }
 }
 
 void DXVAVideoDecodeAccelerator::FlushDecoder(
     int iterations,
     IDirect3DSurface9* src_surface,
     IDirect3DSurface9* dest_surface,
     int picture_buffer_id,
     int input_buffer_id) {
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
@@ skipping 201 matching lines @@
     D3DSURFACE_DESC surface_desc;
     hr = surface->GetDesc(&surface_desc);
     RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
     *width = surface_desc.Width;
     *height = surface_desc.Height;
   }
   return true;
 }
 
 }  // namespace content