[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;
+        }));

[mcasas, 2017/03/07 19:39:37]

Ugh waiting like this.  Can't we somehow inject the FakeJpeg decoder
via some Gpu process backdoor?

[chfremer, 2017/03/07 22:30:38]

I don't see how that would help.
The current behavior is that VideoCaptureDeviceClient only spins up the Gpu
decoder when encountering an Mjpeg frame, and it performs software decode while
waiting for it to initialize. Unless we want to change that behavior, I don't
see a way around waiting.

+  }
   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);
   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