Remove the CHECKs in the DXVA code for the DX11 codepath

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 811 matching lines @@
   hr = d3d11_device_->CreateQuery(&query_desc, d3d11_query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
 
   HMODULE video_processor_dll = ::GetModuleHandle(L"msvproc.dll");
   RETURN_ON_FAILURE(video_processor_dll, "Failed to load video processor",
                     false);
 
   hr = CreateCOMObjectFromDll(video_processor_dll, CLSID_VideoProcessorMFT,
                               __uuidof(IMFTransform),
                               video_format_converter_mft_.ReceiveVoid());
-  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_ON_HR_FAILURE(hr, "Failed to create video format converter", false);
 
   base::win::ScopedComPtr<IMFAttributes> converter_attributes;
   hr = video_format_converter_mft_->GetAttributes(
       converter_attributes.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get converter attributes", false);
 
   hr = converter_attributes->SetUINT32(MF_XVP_PLAYBACK_MODE, TRUE);
   RETURN_ON_HR_FAILURE(
       hr, "Failed to set MF_XVP_PLAYBACK_MODE attribute on converter", false);
@@ skipping 1540 matching lines @@
   hr = MFCreateSample(output_sample.Receive());
   if (FAILED(hr)) {
     RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to create output sample.",
                                     PLATFORM_FAILURE, );
   }
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   hr = MFCreateDXGISurfaceBuffer(__uuidof(ID3D11Texture2D), dest_texture, 0,
                                  FALSE, output_buffer.Receive());
   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 create output sample.",
                                     PLATFORM_FAILURE, );
   }
 
   output_sample->AddBuffer(output_buffer.get());
 
   hr = video_format_converter_mft_->ProcessInput(0, video_frame, 0);
   if (FAILED(hr)) {
     DCHECK(false);
     RETURN_AND_NOTIFY_ON_HR_FAILURE(
         hr, "Failed to convert output sample format.", PLATFORM_FAILURE, );
   }
 
   DWORD status = 0;
   MFT_OUTPUT_DATA_BUFFER format_converter_output = {};
   format_converter_output.pSample = output_sample.get();
   hr = video_format_converter_mft_->ProcessOutput(
       0,  // No flags
       1,  // # of out streams to pull from
       &format_converter_output, &status);
 
   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);
+    DCHECK(false);
     RETURN_AND_NOTIFY_ON_HR_FAILURE(
         hr, "Failed to convert output sample format.", PLATFORM_FAILURE, );
   }
 
   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, );
 
     main_thread_task_runner_->PostTask(
@@ skipping 34 matching lines @@
   // return success occassionally on multi core machines, leading to an
   // infinite loop.
   // Workaround is to have an upper limit of 4 on the number of iterations to
   // wait for the Flush to finish.
 
   HRESULT hr = E_FAIL;
   if (use_dx11_) {
     BOOL query_data = 0;
     hr = d3d11_device_context_->GetData(d3d11_query_.get(), &query_data,
                                         sizeof(BOOL), 0);
-    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);
-    }
+    if (FAILED(hr))
+      DCHECK(false);
   } else {
     hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
   }
 
   if ((hr == S_FALSE) && (++iterations < kMaxIterationsForD3DFlush)) {
     decoder_thread_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushDecoder,
                               base::Unretained(this), iterations, src_surface,
                               dest_surface, picture_buffer_id, input_buffer_id),
         base::TimeDelta::FromMilliseconds(kFlushDecoderSurfaceTimeoutMs));
@@ skipping 11 matching lines @@
     int height) {
   if (!dx11_video_format_converter_media_type_needs_init_)
     return true;
 
   CHECK(video_format_converter_mft_.get());
 
   HRESULT hr = video_format_converter_mft_->ProcessMessage(
       MFT_MESSAGE_SET_D3D_MANAGER,
       reinterpret_cast<ULONG_PTR>(d3d11_device_manager_.get()));
 
-  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);
-  }
+  if (FAILED(hr))
+    DCHECK(false);
+
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr,
                                   "Failed to initialize video format converter",
                                   PLATFORM_FAILURE, false);
 
   video_format_converter_mft_->ProcessMessage(MFT_MESSAGE_NOTIFY_END_STREAMING,
                                               0);
 
   base::win::ScopedComPtr<IMFMediaType> media_type;
   hr = MFCreateMediaType(media_type.Receive());
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "MFCreateMediaType failed",
                                   PLATFORM_FAILURE, false);
 
   hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set major input type",
                                   PLATFORM_FAILURE, false);
 
   hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set input sub type",
                                   PLATFORM_FAILURE, false);
 
   hr = MFSetAttributeSize(media_type.get(), MF_MT_FRAME_SIZE, width, height);
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set media type attributes",
                                   PLATFORM_FAILURE, false);
 
   hr = video_format_converter_mft_->SetInputType(0, media_type.get(), 0);
-  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);
-  }
+  if (FAILED(hr))
+    DCHECK(false);
+
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to set converter input type",
                                   PLATFORM_FAILURE, false);
 
   // It appears that we fail to set MFVideoFormat_ARGB32 as the output media
   // type in certain configurations. Try to fallback to MFVideoFormat_RGB32
   // in such cases. If both fail, then bail.
   bool media_type_set = SetTransformOutputType(
       video_format_converter_mft_.get(), MFVideoFormat_ARGB32, width, height);
   if (!media_type_set) {
     media_type_set = SetTransformOutputType(video_format_converter_mft_.get(),
                                             MFVideoFormat_RGB32, width, height);
   }
 
   if (!media_type_set) {
-    // Remove this once this stabilizes in the field.
-    CHECK(false);
     LOG(ERROR) << "Failed to find a matching RGB output type in the converter";
     return false;
   }
 
   dx11_video_format_converter_media_type_needs_init_ = false;
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(IMFSample* sample,
                                                          int* width,
@@ skipping 88 matching lines @@
   DismissStaleBuffers(true);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media