[Reland] Make D3D11VideoDecoder fall back to VDAVideoDecoder.

To try to reduce time to first frame regressions, this CL makes
D3D11VideoDecoder fall back to VDAVideoDecoder via
FallbacKVideoDecoder.  This prevents a round trip or two between the
GPU and renderer processes.

This relands https://chromium-review.googlesource.com/c/1294810 with
a fix to prevent deleting the preferred decoder during a failed init
callback.  Instead, it posts destruction.

Bug: 832917
Change-Id: I24173ef8c4005961ed8ec0a9125b136b7267e6a7
Reviewed-on: https://chromium-review.googlesource.com/c/1297006Reviewed-by: Dan Sanders <sandersd@chromium.org>
Commit-Queue: Frank Liberato <liberato@chromium.org>
Cr-Commit-Position: refs/heads/master@{#602215}

media/base/fallback_video_decoder.cc

@@ -5,6 +5,8 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/fallback_video_decoder.h"
 #include "media/base/video_decoder_config.h"
@@ -58,7 +60,13 @@ void FallbackVideoDecoder::FallbackInitialize(
   }
 
   did_fallback_ = true;
-  preferred_decoder_.reset();
+  // Post destruction of |preferred_decoder_| so that we don't destroy the
+  // object during the callback.  DeleteSoon doesn't handle custom deleters, so
+  // we post a do-nothing task instead.
+  base::SequencedTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindOnce(base::DoNothing::Once<std::unique_ptr<VideoDecoder>>(),
+                     std::move(preferred_decoder_)));
   selected_decoder_ = fallback_decoder_.get();
   fallback_decoder_->Initialize(config, low_delay, cdm_context, init_cb,
                                 output_cb, waiting_for_decryption_key_cb);

media/base/fallback_video_decoder_unittest.cc

@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_task_environment.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/fallback_video_decoder.h"
 #include "media/base/gmock_callback_support.h"
@@ -70,6 +71,8 @@ class FallbackVideoDecoderUnittest : public ::testing::TestWithParam<bool> {
 
   bool PreferredShouldSucceed() { return GetParam(); }
 
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+
   StrictMock<MockVideoDecoder>* backup_decoder_;
   StrictMock<MockVideoDecoder>* preferred_decoder_;
   VideoDecoder* fallback_decoder_;

media/mojo/services/gpu_mojo_media_client.cc

@@ -8,10 +8,12 @@
 
 #include "base/bind.h"
 #include "base/feature_list.h"
+#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/cdm_factory.h"
+#include "media/base/fallback_video_decoder.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_decoder.h"
 #include "media/gpu/buildflags.h"
@@ -147,22 +149,26 @@ std::unique_ptr<VideoDecoder> GpuMojoMediaClient::CreateVideoDecoder(
       std::make_unique<VideoFrameFactoryImpl>(gpu_task_runner_,
                                               std::move(get_stub_cb)));
 #elif defined(OS_CHROMEOS) || defined(OS_MACOSX) || defined(OS_WIN)
+  std::unique_ptr<VideoDecoder> vda_video_decoder = VdaVideoDecoder::Create(
+      task_runner, gpu_task_runner_, media_log->Clone(), target_color_space,
+      gpu_preferences_, gpu_workarounds_,
+      base::BindRepeating(&GetCommandBufferStub, media_gpu_channel_manager_,
+                          command_buffer_id->channel_token,
+                          command_buffer_id->route_id));
 #if defined(OS_WIN)
   if (base::FeatureList::IsEnabled(kD3D11VideoDecoder)) {
-    return D3D11VideoDecoder::Create(
+    std::unique_ptr<VideoDecoder> d3d11_video_decoder =
+        D3D11VideoDecoder::Create(
             gpu_task_runner_, media_log->Clone(), gpu_preferences_,
             gpu_workarounds_,
-        base::BindRepeating(&GetCommandBufferStub, media_gpu_channel_manager_,
-                            command_buffer_id->channel_token,
-                            command_buffer_id->route_id));
+            base::BindRepeating(
+                &GetCommandBufferStub, media_gpu_channel_manager_,
+                command_buffer_id->channel_token, command_buffer_id->route_id));
+    return base::WrapUnique<VideoDecoder>(new FallbackVideoDecoder(
+        std::move(d3d11_video_decoder), std::move(vda_video_decoder)));
   }
 #endif  // defined(OS_WIN)
-  return VdaVideoDecoder::Create(
-      task_runner, gpu_task_runner_, media_log->Clone(), target_color_space,
-      gpu_preferences_, gpu_workarounds_,
-      base::BindRepeating(&GetCommandBufferStub, media_gpu_channel_manager_,
-                          command_buffer_id->channel_token,
-                          command_buffer_id->route_id));
+  return vda_video_decoder;
 #else
   return nullptr;
 #endif  // defined(OS_ANDROID)

media/renderers/default_decoder_factory.cc

@@ -98,16 +98,9 @@ void DefaultDecoderFactory::CreateVideoDecoders(
           task_runner, gpu_factories, media_log, request_overlay_info_cb,
           target_color_space, video_decoders);
     }
+
     // MojoVideoDecoder replaces any VDA for this platform when it's enabled.
-    bool enable_vda = !base::FeatureList::IsEnabled(media::kMojoVideoDecoder);
-#if defined(OS_WIN)
-    // D3D11VideoDecoder doesn't support as many cases as dxva yet, so don't
-    // turn off hw decode just because it's enabled.
-    // TODO(crbug.com/832171): Move the check for the most common unsupported
-    // cases for D3D11VideoDecoder to the renderer, to save an IPC hop.
-    enable_vda = true;
-#endif
-    if (enable_vda) {
+    if (!base::FeatureList::IsEnabled(media::kMojoVideoDecoder)) {
       video_decoders->push_back(std::make_unique<GpuVideoDecoder>(
           gpu_factories, request_overlay_info_cb, target_color_space,
           media_log));