D3D11VideoDecoder ReleaseMailboxCB and cleanup.

Switched D3D11VideoDecoder to use VideoFrame::ReleaseMailboxCB.

Also added some random small cleanups (error checking, mostly).

Bug: 
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: Ia4492de5c2506678bcdabc16de4c19dde92e4186
Reviewed-on: https://chromium-review.googlesource.com/847679
Commit-Queue: Frank Liberato <liberato@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#526808}

media/gpu/windows/d3d11_h264_accelerator.cc

@@ -25,19 +25,22 @@ namespace media {
 
 class D3D11H264Picture : public H264Picture {
  public:
-  D3D11H264Picture(D3D11PictureBuffer* picture, size_t input_buffer_id)
-      : picture(picture),
-        level_(picture->level()),
-        input_buffer_id_(input_buffer_id) {}
+  D3D11H264Picture(D3D11PictureBuffer* picture)
+      : picture(picture), level_(picture->level()) {
+    picture->set_in_picture_use(true);
+  }
 
   D3D11PictureBuffer* picture;
   size_t level_;
-  size_t input_buffer_id_;
 
  protected:
   ~D3D11H264Picture() override;
 };
 
+D3D11H264Picture::~D3D11H264Picture() {
+  picture->set_in_picture_use(false);
+}
+
 D3D11H264Accelerator::D3D11H264Accelerator(
     D3D11VideoDecoderClient* client,
     Microsoft::WRL::ComPtr<ID3D11VideoDecoder> video_decoder,
@@ -55,9 +58,7 @@ scoped_refptr<H264Picture> D3D11H264Accelerator::CreateH264Picture() {
   if (!picture) {
     return nullptr;
   }
-  picture->set_in_picture_use(true);
-  return base::MakeRefCounted<D3D11H264Picture>(picture,
-                                                client_->input_buffer_id());
+  return base::MakeRefCounted<D3D11H264Picture>(picture);
 }
 
 bool D3D11H264Accelerator::SubmitFrameMetadata(
@@ -80,8 +81,10 @@ bool D3D11H264Accelerator::SubmitFrameMetadata(
       // Hardware is busy.  We should make the call again.
       // TODO(liberato): For now, just busy wait.
       ;
+    } else if (!SUCCEEDED(hr)) {
+      LOG(ERROR) << "DecoderBeginFrame failed";
+      return false;
     } else {
-      CHECK(SUCCEEDED(hr));
       break;
     }
   }
@@ -120,20 +123,27 @@ bool D3D11H264Accelerator::SubmitFrameMetadata(
     i++;
   }
   slice_info_.clear();
-  RetrieveBitstreamBuffer();
-  return true;
+  return RetrieveBitstreamBuffer();
 }
 
-void D3D11H264Accelerator::RetrieveBitstreamBuffer() {
+bool D3D11H264Accelerator::RetrieveBitstreamBuffer() {
+  DCHECK(!bitstream_buffer_bytes_);
+  DCHECK(!bitstream_buffer_size_);
+
   current_offset_ = 0;
   void* buffer;
   UINT buffer_size;
   HRESULT hr = video_context_->GetDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM, &buffer_size,
       &buffer);
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "GetDecoderBuffer (Bitstream) failed";
+    return false;
+  }
   bitstream_buffer_bytes_ = (uint8_t*)buffer;
   bitstream_buffer_size_ = buffer_size;
-  CHECK(SUCCEEDED(hr));
+
+  return true;
 }
 
 bool D3D11H264Accelerator::SubmitSlice(const H264PPS* pps,
@@ -235,12 +245,18 @@ bool D3D11H264Accelerator::SubmitSlice(const H264PPS* pps,
   HRESULT hr = video_context_->GetDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS,
       &buffer_size, &buffer);
-  CHECK(SUCCEEDED(hr));
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "ReleaseDecoderBuffer (PictureParams) failed";
+    return false;
+  }
 
   memcpy(buffer, &pic_param, sizeof(pic_param));
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS);
-  CHECK(SUCCEEDED(hr));
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "ReleaseDecoderBuffer (PictureParams) failed";
+    return false;
+  }
 
   DXVA_Qmatrix_H264 iq_matrix_buf = {};
 
@@ -269,11 +285,18 @@ bool D3D11H264Accelerator::SubmitSlice(const H264PPS* pps,
       video_decoder_.Get(),
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX, &buffer_size,
       &buffer);
-  CHECK(SUCCEEDED(hr));
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "GetDecoderBuffer (QuantMatrix) failed";
+    return false;
+  }
   memcpy(buffer, &iq_matrix_buf, sizeof(iq_matrix_buf));
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(),
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX);
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "ReleaseDecoderBuffer (QuantMatrix) failed";
+    return false;
+  }
 
   // Ideally all slices in a frame are put in the same bitstream buffer.
   // However the bitstream buffer may not fit all the data, so split on the
@@ -287,8 +310,14 @@ bool D3D11H264Accelerator::SubmitSlice(const H264PPS* pps,
   while (remaining_bitstream > 0) {
     if (bitstream_buffer_size_ < remaining_bitstream &&
         slice_info_.size() > 0) {
-      SubmitSliceData();
-      RetrieveBitstreamBuffer();
+      if (!SubmitSliceData()) {
+        LOG(ERROR) << "SubmitSliceData failed";
+        return false;
+      }
+      if (!RetrieveBitstreamBuffer()) {
+        LOG(ERROR) << "RetrieveBitstreamBuffer failed";
+        return false;
+      }
     }
 
     size_t bytes_to_copy = remaining_bitstream;
@@ -331,21 +360,37 @@ bool D3D11H264Accelerator::SubmitSlice(const H264PPS* pps,
   return true;
 }
 
-void D3D11H264Accelerator::SubmitSliceData() {
+bool D3D11H264Accelerator::SubmitSliceData() {
   CHECK(slice_info_.size() > 0);
   UINT buffer_size;
   void* buffer;
+
+  // TODO(liberato): Should we release the other buffers on failure?
+
   HRESULT hr = video_context_->GetDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL,
       &buffer_size, &buffer);
-  CHECK(SUCCEEDED(hr));
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "GetDecoderBuffer (SliceControl) failed";
+    return false;
+  }
+
   CHECK_LE(sizeof(slice_info_[0]) * slice_info_.size(), buffer_size);
   memcpy(buffer, &slice_info_[0], sizeof(slice_info_[0]) * slice_info_.size());
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL);
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "ReleaseDecoderBuffer (SliceControl) failed";
+    return false;
+  }
 
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "ReleaseDecoderBuffer (BitStream) failed";
+    return false;
+  }
+
   D3D11_VIDEO_DECODER_BUFFER_DESC buffers[4] = {};
   buffers[0].BufferType = D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS;
   buffers[0].DataOffset = 0;
@@ -366,39 +411,48 @@ void D3D11H264Accelerator::SubmitSliceData() {
   slice_info_.clear();
   bitstream_buffer_bytes_ = nullptr;
   bitstream_buffer_size_ = 0;
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "SubmitDecoderBuffers failed";
+    return false;
+  }
+
+  return true;
 }
 
 bool D3D11H264Accelerator::SubmitDecode(const scoped_refptr<H264Picture>& pic) {
-  SubmitSliceData();
+  if (!SubmitSliceData()) {
+    LOG(ERROR) << "SubmitSliceData failed";
+    return false;
+  }
 
   HRESULT hr = video_context_->DecoderEndFrame(video_decoder_.Get());
-  CHECK(SUCCEEDED(hr));
+  if (!SUCCEEDED(hr)) {
+    LOG(ERROR) << "DecoderEndFrame failed";
+    return false;
+  }
 
   return true;
 }
 
 void D3D11H264Accelerator::Reset() {
-  if (bitstream_buffer_bytes_) {
-    HRESULT hr = video_context_->ReleaseDecoderBuffer(
-        video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
-
-    bitstream_buffer_bytes_ = nullptr;
-    bitstream_buffer_size_ = 0;
-    current_offset_ = 0;
-    CHECK(SUCCEEDED(hr));
-  }
+  if (!bitstream_buffer_bytes_)
+    return;
+
+  HRESULT hr = video_context_->ReleaseDecoderBuffer(
+      video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
+
+  bitstream_buffer_bytes_ = nullptr;
+  bitstream_buffer_size_ = 0;
+  current_offset_ = 0;
+  CHECK(SUCCEEDED(hr));
 }
 
 bool D3D11H264Accelerator::OutputPicture(
     const scoped_refptr<H264Picture>& pic) {
   scoped_refptr<D3D11H264Picture> our_pic(
       static_cast<D3D11H264Picture*>(pic.get()));
-  client_->OutputResult(our_pic->picture, our_pic->input_buffer_id_);
+  client_->OutputResult(our_pic->picture);
   return true;
 }
 
-D3D11H264Picture::~D3D11H264Picture() {
-  picture->set_in_picture_use(false);
-}
-
 }  // namespace media

media/gpu/windows/d3d11_h264_accelerator.h

@@ -28,10 +28,8 @@ class D3D11PictureBuffer;
 
 class D3D11VideoDecoderClient {
  public:
-  virtual size_t input_buffer_id() const = 0;
   virtual D3D11PictureBuffer* GetPicture() = 0;
-  virtual void OutputResult(D3D11PictureBuffer* picture,
-                            size_t input_buffer_id) = 0;
+  virtual void OutputResult(D3D11PictureBuffer* picture) = 0;
 };
 
 class D3D11H264Accelerator : public H264Decoder::H264Accelerator {
@@ -64,8 +62,8 @@ class D3D11H264Accelerator : public H264Decoder::H264Accelerator {
   bool OutputPicture(const scoped_refptr<H264Picture>& pic) override;
 
  private:
-  void SubmitSliceData();
-  void RetrieveBitstreamBuffer();
+  bool SubmitSliceData();
+  bool RetrieveBitstreamBuffer();
 
   D3D11VideoDecoderClient* client_;
 

media/gpu/windows/d3d11_video_decoder.cc

@@ -11,6 +11,7 @@
 #include "media/base/video_codecs.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
+#include "media/gpu/windows/d3d11_video_decoder_impl.h"
 
 namespace {
 
@@ -46,17 +47,13 @@ namespace media {
 
 D3D11VideoDecoder::D3D11VideoDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
-    base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb,
-    deprecated::OutputWithReleaseMailboxCB output_cb)
+    base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb)
     : impl_task_runner_(std::move(gpu_task_runner)), weak_factory_(this) {
   // We create |impl_| on the wrong thread, but we never use it here.
   // Note that the output callback will hop to our thread, post the video
   // frame, and along with a callback that will hop back to the impl thread
   // when it's released.
-  impl_ = base::MakeUnique<D3D11VideoDecoderImpl>(
-      get_stub_cb, media::BindToCurrentLoop(base::Bind(
-                       &D3D11VideoDecoder::OutputWithThreadHoppingRelease,
-                       weak_factory_.GetWeakPtr(), std::move(output_cb))));
+  impl_ = base::MakeUnique<D3D11VideoDecoderImpl>(get_stub_cb);
   impl_weak_ = impl_->GetWeakPtr();
 }
 
@@ -124,23 +121,4 @@ int D3D11VideoDecoder::GetMaxDecodeRequests() const {
   return impl_->GetMaxDecodeRequests();
 }
 
-void D3D11VideoDecoder::OutputWithThreadHoppingRelease(
-    deprecated::OutputWithReleaseMailboxCB output_cb,
-    deprecated::ReleaseMailboxCB impl_thread_cb,
-    const scoped_refptr<VideoFrame>& video_frame) {
-  // Called on our thread to output a video frame.  Modify the release cb so
-  // that it jumps back to the impl thread.
-  output_cb.Run(
-      base::BindOnce(&D3D11VideoDecoder::OnMailboxReleased,
-                     weak_factory_.GetWeakPtr(), std::move(impl_thread_cb)),
-      video_frame);
-}
-
-void D3D11VideoDecoder::OnMailboxReleased(
-    deprecated::ReleaseMailboxCB impl_thread_cb,
-    const gpu::SyncToken& token) {
-  impl_task_runner_->PostTask(FROM_HERE,
-                              base::BindOnce(std::move(impl_thread_cb), token));
-}
-
 }  // namespace media

media/gpu/windows/d3d11_video_decoder.h

@@ -5,8 +5,6 @@
 #ifndef MEDIA_GPU_D3D11_VIDEO_DECODER_H_
 #define MEDIA_GPU_D3D11_VIDEO_DECODER_H_
 
-#include <d3d11.h>
-
 #include <string>
 
 #include "base/memory/ptr_util.h"
@@ -16,11 +14,11 @@
 #include "gpu/ipc/service/command_buffer_stub.h"
 #include "media/base/video_decoder.h"
 #include "media/gpu/media_gpu_export.h"
-#include "media/gpu/windows/d3d11_video_decoder_impl.h"
-#include "media/gpu/windows/output_with_release_mailbox_cb.h"
 
 namespace media {
 
+class D3D11VideoDecoderImpl;
+
 // Thread-hopping implementation of D3D11VideoDecoder.  It's meant to run on
 // a random thread, and hop to the gpu main thread.  It does this so that it
 // can use the D3D context etc.  What should really happen is that we should
@@ -31,8 +29,7 @@ class MEDIA_GPU_EXPORT D3D11VideoDecoder : public VideoDecoder {
  public:
   D3D11VideoDecoder(
       scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner,
-      base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb,
-      deprecated::OutputWithReleaseMailboxCB output_cb);
+      base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb);
   ~D3D11VideoDecoder() override;
 
   // VideoDecoder implementation:
@@ -50,17 +47,6 @@ class MEDIA_GPU_EXPORT D3D11VideoDecoder : public VideoDecoder {
   int GetMaxDecodeRequests() const override;
 
  private:
-  // Call |output_cb| with a release cb that will hop back to the impl thread
-  // to run |impl_thread_cb| when |video_frame| is released.
-  void OutputWithThreadHoppingRelease(
-      deprecated::OutputWithReleaseMailboxCB output_cb,
-      deprecated::ReleaseMailboxCB impl_thread_cb,
-      const scoped_refptr<VideoFrame>& video_frame);
-
-  // ReleaseCB that's run on our thread, but posts it to the impl thread.
-  void OnMailboxReleased(deprecated::ReleaseMailboxCB impl_thread_cb,
-                         const gpu::SyncToken& token);
-
   // The implementation, which we trampoline to the impl thread.
   // This must be freed on the impl thread.
   std::unique_ptr<D3D11VideoDecoderImpl> impl_;
@@ -71,8 +57,6 @@ class MEDIA_GPU_EXPORT D3D11VideoDecoder : public VideoDecoder {
   // Task runner for |impl_|.  This must be the GPU main thread.
   scoped_refptr<base::SequencedTaskRunner> impl_task_runner_;
 
-  deprecated::OutputWithReleaseMailboxCB output_cb_;
-
   base::WeakPtrFactory<D3D11VideoDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(D3D11VideoDecoder);

media/gpu/windows/d3d11_video_decoder_impl.cc

@@ -9,6 +9,7 @@
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
@@ -27,11 +28,8 @@ static bool MakeContextCurrent(gpu::CommandBufferStub* stub) {
 }  // namespace
 
 D3D11VideoDecoderImpl::D3D11VideoDecoderImpl(
-    base::Callback<gpu::CommandBufferStub*()> get_stub_cb,
-    deprecated::OutputWithReleaseMailboxCB output_cb)
-    : get_stub_cb_(get_stub_cb),
-      output_cb_(std::move(output_cb)),
-      weak_factory_(this) {}
+    base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb)
+    : get_stub_cb_(get_stub_cb), weak_factory_(this) {}
 
 D3D11VideoDecoderImpl::~D3D11VideoDecoderImpl() {
   // TODO(liberato): be sure to clear |picture_buffers_| on the main thread.
@@ -47,7 +45,7 @@ void D3D11VideoDecoderImpl::Initialize(const VideoDecoderConfig& config,
                                        bool low_delay,
                                        CdmContext* cdm_context,
                                        const InitCB& init_cb,
-                                       const OutputCB& /* output_cb */) {
+                                       const OutputCB& output_cb) {
   stub_ = get_stub_cb_.Run();
   if (!MakeContextCurrent(stub_)) {
     init_cb.Run(false);
@@ -57,6 +55,8 @@ void D3D11VideoDecoderImpl::Initialize(const VideoDecoderConfig& config,
   // stub_->AddDestructionObserver(this);
   decoder_helper_ = GLES2DecoderHelper::Create(stub_->decoder());
 
+  output_cb_ = output_cb;
+
   // The device is threadsafe.  Does GetImmediateContext create a new object?
   // If so, then we can just use it on the MCVD thread.  All we need to do is
   // to share the Texture object, somehow, which is likely trivial.  We'd have
@@ -361,14 +361,7 @@ D3D11PictureBuffer* D3D11VideoDecoderImpl::GetPicture() {
   return nullptr;
 }
 
-size_t D3D11VideoDecoderImpl::input_buffer_id() const {
-  // NOTE: nobody uses this for anything.  it just gets returned to us with
-  // OutputResult.  It can be removed once we replace the VDA.
-  return 0;
-}
-
-void D3D11VideoDecoderImpl::OutputResult(D3D11PictureBuffer* buffer,
-                                         size_t input_buffer_id) {
+void D3D11VideoDecoderImpl::OutputResult(D3D11PictureBuffer* buffer) {
   buffer->set_in_client_use(true);
 
   // Note: The pixel format doesn't matter.
@@ -380,12 +373,10 @@ void D3D11VideoDecoderImpl::OutputResult(D3D11PictureBuffer* buffer,
       VideoFrame::ReleaseMailboxCB(), buffer->picture_buffer().size(),
       visible_rect, natural_size, timestamp);
 
-  // TODO(liberato): The VideoFrame release callback will not be called after
-  // MojoVideoDecoderService is destructed.  See VideoFrameFactoryImpl.
-  // NOTE: i think that we drop the picture buffers, which might work okay.
-  output_cb_.Run(base::Bind(&D3D11VideoDecoderImpl::OnMailboxReleased,
-                            weak_factory_.GetWeakPtr(), buffer),
-                 frame);
+  frame->SetReleaseMailboxCB(media::BindToCurrentLoop(
+      base::BindOnce(&D3D11VideoDecoderImpl::OnMailboxReleased,
+                     weak_factory_.GetWeakPtr(), buffer)));
+  output_cb_.Run(frame);
 }
 
 void D3D11VideoDecoderImpl::OnMailboxReleased(

media/gpu/windows/d3d11_video_decoder_impl.h

@@ -27,8 +27,8 @@ namespace media {
 class MEDIA_GPU_EXPORT D3D11VideoDecoderImpl : public VideoDecoder,
                                                public D3D11VideoDecoderClient {
  public:
-  D3D11VideoDecoderImpl(base::Callback<gpu::CommandBufferStub*()> get_stub_cb,
-                        deprecated::OutputWithReleaseMailboxCB output_cb);
+  D3D11VideoDecoderImpl(
+      base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb);
   ~D3D11VideoDecoderImpl() override;
 
   // VideoDecoder implementation:
@@ -47,9 +47,7 @@ class MEDIA_GPU_EXPORT D3D11VideoDecoderImpl : public VideoDecoder,
 
   // D3D11VideoDecoderClient implementation.
   D3D11PictureBuffer* GetPicture() override;
-  void OutputResult(D3D11PictureBuffer* buffer,
-                    size_t input_buffer_id) override;
-  size_t input_buffer_id() const override;
+  void OutputResult(D3D11PictureBuffer* buffer) override;
 
   // Return a weak ptr, since D3D11VideoDecoder constructs callbacks for us.
   base::WeakPtr<D3D11VideoDecoderImpl> GetWeakPtr();
@@ -61,7 +59,7 @@ class MEDIA_GPU_EXPORT D3D11VideoDecoderImpl : public VideoDecoder,
   void OnMailboxReleased(D3D11PictureBuffer* buffer,
                          const gpu::SyncToken& sync_token);
 
-  base::Callback<gpu::CommandBufferStub*()> get_stub_cb_;
+  base::RepeatingCallback<gpu::CommandBufferStub*()> get_stub_cb_;
   gpu::CommandBufferStub* stub_ = nullptr;
   // A helper for creating textures. Only valid while |stub_| is valid.
   std::unique_ptr<GLES2DecoderHelper> decoder_helper_;
@@ -84,7 +82,7 @@ class MEDIA_GPU_EXPORT D3D11VideoDecoderImpl : public VideoDecoder,
 
   std::vector<std::unique_ptr<D3D11PictureBuffer>> picture_buffers_;
 
-  deprecated::OutputWithReleaseMailboxCB output_cb_;
+  VideoDecoder::OutputCB output_cb_;
 
   base::WeakPtrFactory<D3D11VideoDecoderImpl> weak_factory_;
 

media/mojo/services/gpu_mojo_media_client.cc

@@ -30,9 +30,10 @@
 #include "services/service_manager/public/cpp/connect.h"
 #endif  // defined(OS_ANDROID)
 
-#if defined(OS_WIN)
+// OS_WIN guards are needed for cross-compiling on linux.
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_D3D11_VIDEO_DECODER)
 #include "media/gpu/windows/d3d11_video_decoder.h"
-#endif  // defined(OS_WIN)
+#endif  // BUILDFLAG(ENABLE_D3D11_VIDEO_DECODER)
 
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
 #include "media/cdm/cdm_proxy.h"
@@ -64,7 +65,8 @@ std::unique_ptr<MediaDrmStorage> CreateMediaDrmStorage(
 }
 #endif  // defined(OS_ANDROID)
 
-#if defined(OS_ANDROID) || BUILDFLAG(ENABLE_D3D11_VIDEO_DECODER)
+#if defined(OS_ANDROID) || \
+    (defined(OS_WIN) && BUILDFLAG(ENABLE_D3D11_VIDEO_DECODER))
 gpu::CommandBufferStub* GetCommandBufferStub(
     base::WeakPtr<MediaGpuChannelManager> media_gpu_channel_manager,
     base::UnguessableToken channel_token,
@@ -123,7 +125,7 @@ std::unique_ptr<VideoDecoder> GpuMojoMediaClient::CreateVideoDecoder(
       android_overlay_factory_cb_, std::move(request_overlay_info_cb),
       base::MakeUnique<VideoFrameFactoryImpl>(gpu_task_runner_,
                                               std::move(get_stub_cb)));
-#elif BUILDFLAG(ENABLE_D3D11_VIDEO_DECODER)
+#elif defined(OS_WIN) && BUILDFLAG(ENABLE_D3D11_VIDEO_DECODER)
   return base::MakeUnique<D3D11VideoDecoder>(
       gpu_task_runner_,
       base::BindRepeating(&GetCommandBufferStub, media_gpu_channel_manager_,