Use *ForTesting() for D3D12VideoEncodeAccelerator

Create testing methods in D3D12VideoEncodeAccelerator, remove friend
class declaration, and do minor fixups to the unittests.

Bug: 40275246
Change-Id: I234976205dc6940481ac8578db668611ba1796be
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6169405
Reviewed-by: Rafael Cintron <rafael.cintron@microsoft.com>
Reviewed-by: Eugene Zemtsov <eugene@chromium.org>
Commit-Queue: Zhibo Wang <zhibo1.wang@intel.com>
Cr-Commit-Position: refs/heads/main@{#1406560}
diff --git a/media/gpu/windows/d3d12_video_encode_accelerator.cc b/media/gpu/windows/d3d12_video_encode_accelerator.cc
index 49303a2..997a0aa 100644
--- a/media/gpu/windows/d3d12_video_encode_accelerator.cc
+++ b/media/gpu/windows/d3d12_video_encode_accelerator.cc
@@ -24,6 +24,22 @@
 // least 4 output bitstream buffer to be allocated for the encoder to operate
 // properly.
 constexpr size_t kMinNumFramesInFlight = 4;
+
+class VideoEncodeDelegateFactory
+    : public D3D12VideoEncodeAccelerator::VideoEncodeDelegateFactoryInterface {
+ public:
+  std::unique_ptr<D3D12VideoEncodeDelegate> CreateVideoEncodeDelegate(
+      ID3D12VideoDevice3* video_device,
+      VideoCodecProfile profile) override {
+    // TODO(crbug.com/40275246): encoder_ will be initialized here.
+    return nullptr;
+  }
+
+  VideoEncodeAccelerator::SupportedProfiles GetSupportedProfiles(
+      ID3D12VideoDevice3* video_device) override {
+    return D3D12VideoEncodeDelegate::GetSupportedProfiles(video_device);
+  }
+};
 }  // namespace
 
 struct D3D12VideoEncodeAccelerator::InputFrameRef {
@@ -38,7 +54,8 @@
     : device_(std::move(device)),
       child_task_runner_(base::SequencedTaskRunner::GetCurrentDefault()),
       encoder_task_runner_(base::ThreadPool::CreateSingleThreadTaskRunner(
-          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})) {
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
+      encoder_factory_(std::make_unique<VideoEncodeDelegateFactory>()) {
   DVLOGF(2);
   DCHECK_CALLED_ON_VALID_SEQUENCE(child_sequence_checker_);
   DETACH_FROM_SEQUENCE(encoder_sequence_checker_);
@@ -61,6 +78,11 @@
   DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
 }
 
+void D3D12VideoEncodeAccelerator::SetEncoderFactoryForTesting(
+    std::unique_ptr<VideoEncodeDelegateFactoryInterface> encoder_factory) {
+  encoder_factory_ = std::move(encoder_factory);
+}
+
 VideoEncodeAccelerator::SupportedProfiles
 D3D12VideoEncodeAccelerator::GetSupportedProfiles() {
   static const base::NoDestructor supported_profiles(
@@ -68,12 +90,7 @@
         if (!video_device_) {
           return {};
         }
-        if (encoder_factory_) {
-          CHECK_IS_TEST();
-          return encoder_factory_->GetSupportedProfiles(video_device_.Get());
-        }
-        return D3D12VideoEncodeDelegate::GetSupportedProfiles(
-            video_device_.Get());
+        return encoder_factory_->GetSupportedProfiles(video_device_.Get());
       }());
   return *supported_profiles.get();
 }
@@ -159,6 +176,21 @@
       BindOnce(&D3D12VideoEncodeAccelerator::DestroyTask, encoder_weak_this_));
 }
 
+base::SingleThreadTaskRunner*
+D3D12VideoEncodeAccelerator::GetEncoderTaskRunnerForTesting() const {
+  return encoder_task_runner_.get();
+}
+
+size_t D3D12VideoEncodeAccelerator::GetInputFramesQueueSizeForTesting() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
+  return input_frames_queue_.size();
+}
+
+size_t D3D12VideoEncodeAccelerator::GetBitstreamBuffersSizeForTesting() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
+  return bitstream_buffers_.size();
+}
+
 void D3D12VideoEncodeAccelerator::InitializeTask(const Config& config) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(encoder_sequence_checker_);
 
@@ -191,12 +223,10 @@
                         "Failed to create D3D12CopyCommandQueueWrapper"});
   }
 
-  if (encoder_factory_) {
-    CHECK_IS_TEST();
-    encoder_ = encoder_factory_->CreateVideoEncodeDelegate(
-        video_device_.Get(), config.output_profile);
-  } else {
-    // TODO(crbug.com/40275246): encoder_ will be initialized here.
+  encoder_ = encoder_factory_->CreateVideoEncodeDelegate(video_device_.Get(),
+                                                         config.output_profile);
+  if (!encoder_) {
+    return NotifyError(EncoderStatus::Codes::kEncoderUnsupportedCodec);
   }
 
   if (EncoderStatus status = encoder_->Initialize(config); !status.is_ok()) {
diff --git a/media/gpu/windows/d3d12_video_encode_accelerator.h b/media/gpu/windows/d3d12_video_encode_accelerator.h
index 7cf1450..b728ba2 100644
--- a/media/gpu/windows/d3d12_video_encode_accelerator.h
+++ b/media/gpu/windows/d3d12_video_encode_accelerator.h
@@ -40,6 +40,9 @@
       Microsoft::WRL::ComPtr<ID3D12Device> device);
   ~D3D12VideoEncodeAccelerator() override;
 
+  void SetEncoderFactoryForTesting(
+      std::unique_ptr<VideoEncodeDelegateFactoryInterface> encoder_factory);
+
   SupportedProfiles GetSupportedProfiles() override;
   bool Initialize(const Config& config,
                   Client* client,
@@ -52,9 +55,11 @@
       const std::optional<gfx::Size>& size) override;
   void Destroy() override;
 
- private:
-  friend class D3D12VideoEncodeAcceleratorTest;
+  base::SingleThreadTaskRunner* GetEncoderTaskRunnerForTesting() const;
+  size_t GetInputFramesQueueSizeForTesting() const;
+  size_t GetBitstreamBuffersSizeForTesting() const;
 
+ private:
   void InitializeTask(const Config& config);
 
   void UseOutputBitstreamBufferTask(BitstreamBuffer buffer);
@@ -108,7 +113,6 @@
   std::unique_ptr<D3D12CopyCommandQueueWrapper> copy_command_queue_
       GUARDED_BY_CONTEXT(encoder_sequence_checker_);
 
-  // The alternate factory to create the |encoder_| for testing.
   std::unique_ptr<VideoEncodeDelegateFactoryInterface> encoder_factory_;
   std::unique_ptr<D3D12VideoEncodeDelegate> encoder_
       GUARDED_BY_CONTEXT(encoder_sequence_checker_);
diff --git a/media/gpu/windows/d3d12_video_encode_accelerator_unittest.cc b/media/gpu/windows/d3d12_video_encode_accelerator_unittest.cc
index ee8ad18..7559976 100644
--- a/media/gpu/windows/d3d12_video_encode_accelerator_unittest.cc
+++ b/media/gpu/windows/d3d12_video_encode_accelerator_unittest.cc
@@ -145,8 +145,8 @@
         new D3D12VideoEncodeAccelerator(mock_device_));
     client_ = std::make_unique<NiceMock<MockVideoEncodeAcceleratorClient>>();
     static_cast<D3D12VideoEncodeAccelerator*>(video_encode_accelerator_.get())
-        ->encoder_factory_ =
-        std::make_unique<MockVideoEncoderDelegateFactory>();
+        ->SetEncoderFactoryForTesting(
+            std::make_unique<MockVideoEncoderDelegateFactory>());
   }
 
   VideoEncodeAccelerator::Config SupportedProfileToConfig(
@@ -173,32 +173,31 @@
         std::move(mock_gpu_memory_buffer), base::TimeDelta{});
   }
 
-  void WaitForEncoderTasksToComplete() {
+  void WaitForEncoderTasksToComplete() const {
     base::RunLoop run_loop;
     auto* d3d12_video_encode_accelerator =
         static_cast<D3D12VideoEncodeAccelerator*>(
             video_encode_accelerator_.get());
-    d3d12_video_encode_accelerator->encoder_task_runner_->PostTask(
+    d3d12_video_encode_accelerator->GetEncoderTaskRunnerForTesting()->PostTask(
         FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
   }
 
-  void CheckInputFramesQueueAndBitstreamBuffersAreEitherEmpty() {
+  void CheckInputFramesQueueAndBitstreamBuffersAreEitherEmpty() const {
     auto* d3d12_video_encode_accelerator =
         static_cast<D3D12VideoEncodeAccelerator*>(
             video_encode_accelerator_.get());
     base::RunLoop run_loop;
-    d3d12_video_encode_accelerator->encoder_task_runner_->PostTask(
-        FROM_HERE, base::BindOnce(
-                       [](const D3D12VideoEncodeAccelerator* encoder,
-                          base::OnceClosure quit_closure) {
-                         DCHECK_CALLED_ON_VALID_SEQUENCE(
-                             encoder->encoder_sequence_checker_);
-                         EXPECT_TRUE(encoder->input_frames_queue_.empty() ||
-                                     encoder->bitstream_buffers_.empty());
-                         std::move(quit_closure).Run();
-                       },
-                       d3d12_video_encode_accelerator, run_loop.QuitClosure()));
+    d3d12_video_encode_accelerator->GetEncoderTaskRunnerForTesting()->PostTask(
+        FROM_HERE,
+        base::BindOnce(
+            [](const D3D12VideoEncodeAccelerator* encoder,
+               base::OnceClosure quit_closure) {
+              EXPECT_TRUE(encoder->GetInputFramesQueueSizeForTesting() == 0 ||
+                          encoder->GetBitstreamBuffersSizeForTesting() == 0);
+              std::move(quit_closure).Run();
+            },
+            d3d12_video_encode_accelerator, run_loop.QuitClosure()));
     run_loop.Run();
   }