Allow video_decode_accelerator_unittest to be run in an isolate.

media/gpu/video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 31 matching lines @@
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/launcher/unit_test_launcher.h"
+#include "base/test/test_suite.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/config/gpu_driver_bug_workarounds.h"
 #include "media/filters/h264_parser.h"
 #include "media/gpu/fake_video_decode_accelerator.h"
 #include "media/gpu/gpu_video_decode_accelerator_factory.h"
 #include "media/gpu/rendering_helper.h"
 #include "media/gpu/video_accelerator_unittest_helpers.h"
@@ skipping 123 matching lines @@
 const gfx::Size kThumbnailsPageSize(1600, 1200);
 const gfx::Size kThumbnailSize(160, 120);
 const int kMD5StringLength = 32;
 
 // Read in golden MD5s for the thumbnailed rendering of this video
 void ReadGoldenThumbnailMD5s(const TestVideoFile* video_file,
                              std::vector<std::string>* md5_strings) {
   base::FilePath filepath(video_file->file_name);
   filepath = filepath.AddExtension(FILE_PATH_LITERAL(".md5"));
   std::string all_md5s;
-  base::ReadFileToString(filepath, &all_md5s);
+  base::ReadFileToString(base::MakeAbsoluteFilePath(filepath), &all_md5s);
   *md5_strings = base::SplitString(all_md5s, "\n", base::TRIM_WHITESPACE,
                                    base::SPLIT_WANT_ALL);
   // Check these are legitimate MD5s.
   for (const std::string& md5_string : *md5_strings) {
     // Ignore the empty string added by SplitString
     if (!md5_string.length())
       continue;
     // Ignore comments
     if (md5_string.at(0) == '#')
       continue;
@@ skipping 972 matching lines @@
       LOG_ASSERT(base::StringToInt(fields[5], &video_file->min_fps_render));
     if (!fields[6].empty())
       LOG_ASSERT(base::StringToInt(fields[6], &video_file->min_fps_no_render));
     int profile = -1;
     if (!fields[7].empty())
       LOG_ASSERT(base::StringToInt(fields[7], &profile));
     video_file->profile = static_cast<VideoCodecProfile>(profile);
 
     // Read in the video data.
     base::FilePath filepath(video_file->file_name);
-    LOG_ASSERT(base::ReadFileToString(filepath, &video_file->data_str))
+    LOG_ASSERT(base::ReadFileToString(base::MakeAbsoluteFilePath(filepath),
+                                      &video_file->data_str))
         << "test_video_file: " << filepath.MaybeAsASCII();
 
     test_video_files->push_back(std::move(video_file));
   }
 }
 
 void VideoDecodeAcceleratorTest::UpdateTestVideoFileParams(
     size_t num_concurrent_decoders,
     int reset_point,
     TestFilesVector* test_video_files) {
@@ skipping 449 matching lines @@
                         false,
                         false),
         std::make_tuple(kMinSupportedNumConcurrentDecoders + 1,
                         1,
                         1,
                         END_OF_STREAM_RESET,
                         CS_RESET,
                         false,
                         false)));
 
+// Allow MAYBE macro substitution.
+#define WRAPPED_INSTANTIATE_TEST_CASE_P(a, b, c) \
+  INSTANTIATE_TEST_CASE_P(a, b, c)
+
+#if defined(OS_WIN)
+// There are no reference images for windows.
+#define MAYBE_Thumbnail DISABLED_Thumbnail
+#else
+#define MAYBE_Thumbnail Thumbnail
+#endif
 // Thumbnailing test
-INSTANTIATE_TEST_CASE_P(
-    Thumbnail,
+WRAPPED_INSTANTIATE_TEST_CASE_P(
+    MAYBE_Thumbnail,
     VideoDecodeAcceleratorParamTest,
     ::testing::Values(
         std::make_tuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET, false, true)));
 
 // Measure the median of the decode time when VDA::Decode is called 30 times per
 // second.
 TEST_F(VideoDecodeAcceleratorTest, TestDecodeTimeMedian) {
   RenderingHelperParams helper_params;
 
   // Disable rendering by setting the rendering_fps = 0.
@@ skipping 39 matching lines @@
   g_env->GetRenderingTaskRunner()->DeleteSoon(FROM_HERE, note);
   WaitUntilIdle();
 };
 
 // TODO(fischman, vrk): add more tests!  In particular:
 // - Test life-cycle: Seek/Stop/Pause/Play for a single decoder.
 // - Test alternate configurations
 // - Test failure conditions.
 // - Test frame size changes mid-stream
 
+class VDATestSuite : public base::TestSuite {
+ public:
+  VDATestSuite(int argc, char** argv) : base::TestSuite(argc, argv) {}
+
+  int Run() {
+#if defined(OS_WIN) || defined(USE_OZONE)
+    // For windows the decoding thread initializes the media foundation decoder
+    // which uses COM. We need the thread to be a UI thread.
+    // On Ozone, the backend initializes the event system using a UI
+    // thread.
+    base::MessageLoopForUI main_loop;
+#else
+    base::MessageLoop main_loop;
+#endif  // OS_WIN || USE_OZONE
+
+#if defined(USE_OZONE)
+    ui::OzonePlatform::InitializeForUI();
+#endif
+
+#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
+    media::VaapiWrapper::PreSandboxInitialization();
+#elif defined(OS_WIN)
+    media::DXVAVideoDecodeAccelerator::PreSandboxInitialization();
+#endif
+    return base::TestSuite::Run();
+  }
+};
+
 }  // namespace
 }  // namespace media
 
 int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
-#if defined(OS_WIN)
-  base::CommandLine::InitUsingArgvForTesting(argc, argv);
-#else
-  base::CommandLine::Init(argc, argv);
-#endif
+  media::VDATestSuite test_suite(argc, argv);
 
   // Needed to enable DVLOG through --vmodule.
   logging::LoggingSettings settings;
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   LOG_ASSERT(logging::InitLogging(settings));
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   DCHECK(cmd_line);
 
   base::CommandLine::SwitchMap switches = cmd_line->GetSwitches();
@@ skipping 36 matching lines @@
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
     if (it->first == "test_import") {
       media::g_test_import = true;
       continue;
     }
-    LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
-#if defined(OS_WIN) || defined(USE_OZONE)
-  // For windows the decoding thread initializes the media foundation decoder
-  // which uses COM. We need the thread to be a UI thread.
-  // On Ozone, the backend initializes the event system using a UI
-  // thread.
-  base::MessageLoopForUI main_loop;
-#else
-  base::MessageLoop main_loop;
-#endif  // OS_WIN || USE_OZONE
-
-#if defined(USE_OZONE)
-  ui::OzonePlatform::InitializeForUI();
-#endif
-
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  media::VaapiWrapper::PreSandboxInitialization();
-#elif defined(OS_WIN)
-  media::DXVAVideoDecodeAccelerator::PreSandboxInitialization();
-#endif
 
   media::g_env =
       reinterpret_cast<media::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoDecodeAcceleratorTestEnvironment()));
 
-  return RUN_ALL_TESTS();
+  return base::LaunchUnitTestsSerially(
+      argc, argv,
+      base::Bind(&media::VDATestSuite::Run, base::Unretained(&test_suite)));
 }