JDA unittest: don't require the test file in /media/test/data/.

media/gpu/jpeg_decode_accelerator_unittest.cc

 // Copyright 2015 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.
 
 // This has to be included first.
 // See http://code.google.com/p/googletest/issues/detail?id=371
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 295 matching lines @@
   }
   void SetUp() override;
   void TearDown() override;
 
   // Create all black test image with |width| and |height| size.
   bool CreateTestJpegImage(int width, int height, base::FilePath* filename);
 
   // Read image from |filename| to |image_data|.
   void ReadTestJpegImage(base::FilePath& filename, TestImageFile* image_data);
 
+  // Returns a file path for a file in what name specified or media/test/data
+  // directory.  If the original file path is existed, returns it first.
+  base::FilePath GetOriginalOrTestDataFilePath(const std::string& name);
+
   // Parsed data of |test_1280x720_jpeg_file_|.
   std::unique_ptr<TestImageFile> image_data_1280x720_black_;
   // Parsed data of |test_640x368_jpeg_file_|.
   std::unique_ptr<TestImageFile> image_data_640x368_black_;
   // Parsed data of |test_640x360_jpeg_file_|.
   std::unique_ptr<TestImageFile> image_data_640x360_black_;
   // Parsed data of "peach_pi-1280x720.jpg".
   std::unique_ptr<TestImageFile> image_data_1280x720_default_;
   // Parsed data of failure image.
   std::unique_ptr<TestImageFile> image_data_invalid_;
@@ skipping 26 matching lines @@
   image_data_640x368_black_.reset(
       new TestImageFile(test_640x368_jpeg_file_.value()));
   ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(test_640x368_jpeg_file_,
                                             image_data_640x368_black_.get()));
 
   image_data_640x360_black_.reset(
       new TestImageFile(test_640x360_jpeg_file_.value()));
   ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(test_640x360_jpeg_file_,
                                             image_data_640x360_black_.get()));
 
-  base::FilePath default_jpeg_file = GetTestDataFilePath(kDefaultJpegFilename);
+  base::FilePath default_jpeg_file =
+      GetOriginalOrTestDataFilePath(kDefaultJpegFilename);
   image_data_1280x720_default_.reset(new TestImageFile(kDefaultJpegFilename));
   ASSERT_NO_FATAL_FAILURE(
       ReadTestJpegImage(default_jpeg_file, image_data_1280x720_default_.get()));
 
   image_data_invalid_.reset(new TestImageFile("failure.jpg"));
   image_data_invalid_->data_str.resize(100, 0);
   image_data_invalid_->visible_size.SetSize(1280, 720);
   image_data_invalid_->output_size = VideoFrame::AllocationSize(
       PIXEL_FORMAT_I420, image_data_invalid_->visible_size);
 
   // |user_jpeg_filenames_| may include many files and use ';' as delimiter.
   std::vector<base::FilePath::StringType> filenames = base::SplitString(
       user_jpeg_filenames_, base::FilePath::StringType(1, ';'),
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (const auto& filename : filenames) {
-    base::FilePath input_file = GetTestDataFilePath(filename);
+    base::FilePath input_file = GetOriginalOrTestDataFilePath(filename);
     auto image_data = base::MakeUnique<TestImageFile>(filename);
     ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(input_file, image_data.get()));
     image_data_user_.push_back(std::move(image_data));
   }
 }
 
 void JpegDecodeAcceleratorTestEnvironment::TearDown() {
   base::DeleteFile(test_1280x720_jpeg_file_, false);
   base::DeleteFile(test_640x368_jpeg_file_, false);
   base::DeleteFile(test_640x360_jpeg_file_, false);
@@ skipping 27 matching lines @@
   ASSERT_TRUE(ParseJpegPicture(
       reinterpret_cast<const uint8_t*>(image_data->data_str.data()),
       image_data->data_str.size(), &image_data->parse_result));
   image_data->visible_size.SetSize(
       image_data->parse_result.frame_header.visible_width,
       image_data->parse_result.frame_header.visible_height);
   image_data->output_size =
       VideoFrame::AllocationSize(PIXEL_FORMAT_I420, image_data->visible_size);
 }
 
+base::FilePath
+JpegDecodeAcceleratorTestEnvironment::GetOriginalOrTestDataFilePath(
+    const std::string& name) {
+  base::FilePath original_file_path = base::FilePath(name);
+  base::FilePath return_file_path = GetTestDataFilePath(name);
+
+  if (PathExists(original_file_path))
+    return_file_path = original_file_path;
+
+  VLOG(3) << "Use file path " << return_file_path.value();
+  return return_file_path;
+}
+
 class JpegDecodeAcceleratorTest : public ::testing::Test {
  protected:
   JpegDecodeAcceleratorTest() {}
 
   void TestDecode(size_t num_concurrent_decoders);
 
   // The elements of |test_image_files_| are owned by
   // JpegDecodeAcceleratorTestEnvironment.
   std::vector<TestImageFile*> test_image_files_;
   std::vector<ClientState> expected_status_;
@@ skipping 147 matching lines @@
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env = reinterpret_cast<media::JpegDecodeAcceleratorTestEnvironment*>(
       testing::AddGlobalTestEnvironment(
           new media::JpegDecodeAcceleratorTestEnvironment(jpeg_filenames)));
 
   return RUN_ALL_TESTS();
 }