[Mojo Video Capture] Add test coverage for accelerated jpeg decoding

content/browser/renderer_host/media/video_capture_browsertest.cc

 // Copyright 2017 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 "base/command_line.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
@@ skipping 46 matching lines @@
   MOCK_METHOD2(Closed, void(MediaStreamType, int));
   MOCK_METHOD2(Aborted, void(MediaStreamType, int));
 };
 
 struct TestParams {
   std::string fake_device_factory_config_string;
   size_t device_index_to_use;
   media::VideoPixelFormat pixel_format_to_use;
   gfx::Size resolution_to_use;
   float frame_rate_to_use;
+  bool exercise_accelerated_jpeg_decoding;
 };
 
 struct FrameInfo {
   gfx::Size size;
   media::VideoPixelFormat pixel_format;
   media::VideoPixelStorage storage_type;
   base::TimeDelta timestamp;
 };
 
 class VideoCaptureBrowserTest
@@ skipping 32 matching lines @@
 
     video_capture_manager_->Close(session_id_);
   }
 
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(
         switches::kUseFakeDeviceForMediaStream,
         GetParam().fake_device_factory_config_string);
     command_line->AppendSwitch(switches::kUseFakeUIForMediaStream);
+    if (GetParam().exercise_accelerated_jpeg_decoding) {
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kUseFakeJpegDecodeAccelerator);
+    } else {
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kDisableAcceleratedMjpegDecode);
+    }
   }
 
   // This cannot be part of an override of SetUp(), because at the time when
   // SetUp() is invoked, the BrowserMainLoop does not exist yet.
   void SetUpRequiringBrowserMainLoopOnMainThread() {
     BrowserMainLoop* browser_main_loop = BrowserMainLoop::GetInstance();
     ASSERT_TRUE(browser_main_loop);
     media_stream_manager_ = browser_main_loop->media_stream_manager();
     ASSERT_TRUE(media_stream_manager_);
   }
@@ skipping 52 matching lines @@
       base::Bind(&VideoCaptureBrowserTest::SetUpAndStartCaptureDeviceOnIOThread,
                  base::Unretained(this), std::move(after_start_continuation)));
   run_loop.Run();
 }
 
 IN_PROC_BROWSER_TEST_P(VideoCaptureBrowserTest,
                        ReceiveFramesFromFakeCaptureDevice) {
   SetUpRequiringBrowserMainLoopOnMainThread();
 
   std::vector<FrameInfo> received_frame_infos;
-  static const size_t kNumFramesToReceive = 3;
+  static const size_t kMinFramesToReceive = 3;
+  static const size_t kMaxFramesToReceive = 300;
   base::RunLoop run_loop;
 
   auto quit_run_loop_on_current_thread_cb =
       media::BindToCurrentLoop(run_loop.QuitClosure());
   auto finish_test_cb =
       base::Bind(&VideoCaptureBrowserTest::TearDownCaptureDeviceOnIOThread,
                  base::Unretained(this),
                  std::move(quit_run_loop_on_current_thread_cb), true);
 
+  bool must_wait_for_gpu_decode_to_start = false;
+  if (GetParam().exercise_accelerated_jpeg_decoding) {
+    // Since the GPU jpeg decoder is created asynchronously while decoding
+    // in software is ongoing, we have to keep pushing frames until a message
+    // arrives that tells us that the GPU decoder is being used. Otherwise,
+    // it may happen that all test frames are decoded using the non-GPU
+    // decoding path before the GPU decoder has started getting used.
+    must_wait_for_gpu_decode_to_start = true;
+    EXPECT_CALL(mock_controller_event_handler_, OnStartedUsingGpuDecode(_))
+        .WillOnce(InvokeWithoutArgs([&must_wait_for_gpu_decode_to_start]() {
+          must_wait_for_gpu_decode_to_start = false;
+        }));
+  }
   EXPECT_CALL(mock_controller_event_handler_, DoOnBufferCreated(_, _, _, _))
       .Times(AtLeast(1));
   EXPECT_CALL(mock_controller_event_handler_, OnBufferReady(_, _, _))
-      .WillRepeatedly(
-          Invoke([&received_frame_infos, &finish_test_cb](
-                     VideoCaptureControllerID id, int buffer_id,
-                     const media::mojom::VideoFrameInfoPtr& frame_info) {
+      .WillRepeatedly(Invoke(
+          [&received_frame_infos, &must_wait_for_gpu_decode_to_start,
+           &finish_test_cb](VideoCaptureControllerID id, int buffer_id,
+                            const media::mojom::VideoFrameInfoPtr& frame_info) {
             FrameInfo received_frame_info;
             received_frame_info.pixel_format = frame_info->pixel_format;
             received_frame_info.storage_type = frame_info->storage_type;
             received_frame_info.size = frame_info->coded_size;
             received_frame_info.timestamp = frame_info->timestamp;
             received_frame_infos.emplace_back(received_frame_info);
-            if (received_frame_infos.size() >= kNumFramesToReceive) {
+            if ((received_frame_infos.size() >= kMinFramesToReceive &&
+                 !must_wait_for_gpu_decode_to_start) ||
+                (received_frame_infos.size() == kMaxFramesToReceive)) {
               finish_test_cb.Run();
             }
           }));
 
   base::Closure do_nothing;
   BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureBrowserTest::SetUpAndStartCaptureDeviceOnIOThread,
                  base::Unretained(this), std::move(do_nothing)));
   run_loop.Run();
 
-  EXPECT_GE(received_frame_infos.size(), kNumFramesToReceive);
+  EXPECT_FALSE(must_wait_for_gpu_decode_to_start);
+  EXPECT_GE(received_frame_infos.size(), kMinFramesToReceive);
+  EXPECT_LT(received_frame_infos.size(), kMaxFramesToReceive);
   base::TimeDelta previous_timestamp;
   bool first_frame = true;
   for (const auto& frame_info : received_frame_infos) {
     EXPECT_EQ(GetParam().pixel_format_to_use, frame_info.pixel_format);
     EXPECT_EQ(media::PIXEL_STORAGE_CPU, frame_info.storage_type);
     EXPECT_EQ(GetParam().resolution_to_use, frame_info.size);
     // Timestamps are expected to increase
     if (!first_frame)
       EXPECT_GT(frame_info.timestamp, previous_timestamp);
     first_frame = false;
     previous_timestamp = frame_info.timestamp;
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     ,
     VideoCaptureBrowserTest,
     Values(TestParams{"fps=25,device-count=2", 0, media::PIXEL_FORMAT_I420,
-                      gfx::Size(1280, 720), 25.0f},
+                      gfx::Size(1280, 720), 25.0f, false},
            // The 2nd device outputs Y16
            TestParams{"fps=25,device-count=2", 1, media::PIXEL_FORMAT_Y16,
-                      gfx::Size(1280, 720), 25.0f},
+                      gfx::Size(1280, 720), 25.0f, false},
            TestParams{"fps=15,device-count=2", 1, media::PIXEL_FORMAT_Y16,
-                      gfx::Size(640, 480), 15.0f},
+                      gfx::Size(640, 480), 15.0f, false},
            // The 3rd device outputs MJPEG, which is converted to I420.
            TestParams{"fps=15,device-count=3", 2, media::PIXEL_FORMAT_I420,
-                      gfx::Size(640, 480), 25.0f}));
+                      gfx::Size(640, 480), 25.0f, false},
+           TestParams{"fps=6,device-count=3", 2, media::PIXEL_FORMAT_I420,
+                      gfx::Size(640, 480), 6.0f, true}));
 
 }  // namespace content