Delete GetExecutablePath and related unused code.

webrtc/media/base/videoframe_unittest.h

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_
 #define WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_
 
 #include <algorithm>
 #include <memory>
 #include <string>
 
 #include "libyuv/convert.h"
 #include "libyuv/convert_from.h"
 #include "libyuv/planar_functions.h"
 #include "libyuv/rotate.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/common_video/rotation.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/media/base/videocommon.h"
 #include "webrtc/media/base/videoframe.h"
+#include "webrtc/test/testsupport/fileutils.h"
 
 #if defined(_MSC_VER)
 #define ALIGN16(var) __declspec(align(16)) var
 #else
 #define ALIGN16(var) var __attribute__((aligned(16)))
 #endif
 
-#define kImageFilename "faces.1280x720_P420.yuv"
-#define kJpeg420Filename "faces_I420.jpg"
-#define kJpeg422Filename "faces_I422.jpg"
-#define kJpeg444Filename "faces_I444.jpg"
-#define kJpeg411Filename "faces_I411.jpg"
-#define kJpeg400Filename "faces_I400.jpg"
+#define kImageFilename "media/faces.1280x720_P420"
+#define kYuvExtension "yuv"
+#define kJpeg420Filename "media/faces_I420"
+#define kJpeg422Filename "media/faces_I422"
+#define kJpeg444Filename "media/faces_I444"
+#define kJpeg411Filename "media/faces_I411"
+#define kJpeg400Filename "media/faces_I400"
+#define kJpegExtension "jpg"
 
 // Generic test class for testing various video frame implementations.
 template <class T>
 class VideoFrameTest : public testing::Test {
  public:
   VideoFrameTest() : repeat_(1) {}
 
  protected:
   static const int kWidth = 1280;
   static const int kHeight = 720;
   static const int kAlignment = 16;
   static const int kMinWidthAll = 1;  // Constants for ConstructYUY2AllSizes.
   static const int kMinHeightAll = 1;
   static const int kMaxWidthAll = 17;
   static const int kMaxHeightAll = 23;
 
   // Load a video frame from disk.
   bool LoadFrameNoRepeat(T* frame) {
     int save_repeat = repeat_;  // This LoadFrame disables repeat.
     repeat_ = 1;
-    bool success = LoadFrame(kImageFilename, cricket::FOURCC_I420,
-                            kWidth, kHeight, frame);
+    bool success = LoadFrame(LoadSample(kImageFilename, kYuvExtension).get(),
+                             cricket::FOURCC_I420,
+                             kWidth, kHeight, frame);
     repeat_ = save_repeat;
     return success;
   }
 
   bool LoadFrame(const std::string& filename,
                  uint32_t format,
                  int32_t width,
                  int32_t height,
                  T* frame) {
     return LoadFrame(filename, format, width, height, width, abs(height),
@@ skipping 59 matching lines @@
                  webrtc::VideoRotation rotation,
                  T* frame) {
     bool ret = false;
     for (int i = 0; i < repeat_; ++i) {
       ret = frame->Init(format, width, height, dw, dh,
                         sample, sample_size, 0, rotation);
     }
     return ret;
   }
 
-  rtc::MemoryStream* LoadSample(const std::string& filename) {
-    rtc::Pathname path(cricket::GetTestFilePath(filename));
+  std::unique_ptr<rtc::MemoryStream> LoadSample(const std::string& filename,
+                                                const std::string& extension) {
+    rtc::Pathname path(webrtc::test::ResourcePath(filename, extension));
     std::unique_ptr<rtc::FileStream> fs(
         rtc::Filesystem::OpenFile(path, "rb"));
     if (!fs.get()) {
       LOG(LS_ERROR) << "Could not open test file path: " << path.pathname()
                     << " from current dir "
                     << rtc::Filesystem::GetCurrentDirectory().pathname();
       return NULL;
     }
 
     char buf[4096];
     std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream());
     rtc::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get());
     if (res != rtc::SR_SUCCESS) {
       LOG(LS_ERROR) << "Could not load test file path: " << path.pathname();
       return NULL;
     }
 
-    return ms.release();
+    return ms;
   }
 
   bool DumpSample(const std::string& filename, const void* buffer, int size) {
     rtc::Pathname path(filename);
     std::unique_ptr<rtc::FileStream> fs(
         rtc::Filesystem::OpenFile(path, "wb"));
     if (!fs.get()) {
       return false;
     }
 
     return (fs->Write(buffer, size, NULL, NULL) == rtc::SR_SUCCESS);
   }
 
   // Create a test image in the desired color space.
   // The image is a checkerboard pattern with 63x63 squares, which allows
   // I420 chroma artifacts to easily be seen on the square boundaries.
   // The pattern is { { green, orange }, { blue, purple } }
   // There is also a gradient within each square to ensure that the luma
   // values are handled properly.
-  rtc::MemoryStream* CreateYuv422Sample(uint32_t fourcc,
-                                        uint32_t width,
-                                        uint32_t height) {
+  std::unique_ptr<rtc::MemoryStream> CreateYuv422Sample(uint32_t fourcc,
+                                                        uint32_t width,
+                                                        uint32_t height) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
       return NULL;
     }
 
     std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     int awidth = (width + 1) & ~1;
     int size = awidth * 2 * height;
     if (!ms->ReserveSize(size)) {
       return NULL;
     }
     for (uint32_t y = 0; y < height; ++y) {
       for (int x = 0; x < awidth; x += 2) {
         uint8_t quad[4];
         quad[y1_pos] = (x % 63 + y % 63) + 64;
         quad[y2_pos] = ((x + 1) % 63 + y % 63) + 64;
         quad[u_pos] = ((x / 63) & 1) ? 192 : 64;
         quad[v_pos] = ((y / 63) & 1) ? 192 : 64;
         ms->Write(quad, sizeof(quad), NULL, NULL);
       }
     }
-    return ms.release();
+    return ms;
   }
 
   // Create a test image for YUV 420 formats with 12 bits per pixel.
-  rtc::MemoryStream* CreateYuvSample(uint32_t width,
-                                     uint32_t height,
-                                     uint32_t bpp) {
+  std::unique_ptr<rtc::MemoryStream> CreateYuvSample(uint32_t width,
+                                                     uint32_t height,
+                                                     uint32_t bpp) {
     std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bpp / 8)) {
       return NULL;
     }
 
     for (uint32_t i = 0; i < width * height * bpp / 8; ++i) {
       uint8_t value = ((i / 63) & 1) ? 192 : 64;
       ms->Write(&value, sizeof(value), NULL, NULL);
     }
-    return ms.release();
+    return ms;
   }
 
-  rtc::MemoryStream* CreateRgbSample(uint32_t fourcc,
-                                     uint32_t width,
-                                     uint32_t height) {
+  std::unique_ptr<rtc::MemoryStream> CreateRgbSample(uint32_t fourcc,
+                                                     uint32_t width,
+                                                     uint32_t height) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return NULL;
     }
 
     std::unique_ptr<rtc::MemoryStream> ms(
         new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bytes)) {
       return NULL;
     }
 
     for (uint32_t y = 0; y < height; ++y) {
       for (uint32_t x = 0; x < width; ++x) {
         uint8_t rgb[4] = {255, 255, 255, 255};
         rgb[r_pos] = ((x / 63) & 1) ? 224 : 32;
         rgb[g_pos] = (x % 63 + y % 63) + 96;
         rgb[b_pos] = ((y / 63) & 1) ? 224 : 32;
         ms->Write(rgb, bytes, NULL, NULL);
       }
     }
-    return ms.release();
+    return ms;
   }
 
   // Simple conversion routines to verify the optimized VideoFrame routines.
   // Converts from the specified colorspace to I420.
   std::unique_ptr<T> ConvertYuv422(const rtc::MemoryStream* ms,
                                    uint32_t fourcc,
                                    uint32_t width,
                                    uint32_t height) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
@@ skipping 800 matching lines @@
                                                  out_size));  // stride.
     EXPECT_TRUE(IsPlaneEqual("argb", pixel, out_size,
                              out, out_size,
                              out_size, 1, 2));
   }
 
   // Test constructing an image from an I420 buffer with horizontal cropping.
   void ConstructI420CropHorizontal() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight,
+    ASSERT_TRUE(LoadFrame(kImageFilename, kYuvExtension,
+                          cricket::FOURCC_I420, kWidth, kHeight,
                           kWidth * 3 / 4, kHeight, webrtc::kVideoRotation_0,
                           &frame2));
     EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 0));
   }
 
   // Test constructing an image from a YUY2 buffer with horizontal cropping.
   void ConstructYuy2CropHorizontal() {
     T frame1, frame2;
     std::unique_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
@@ skipping 18 matching lines @@
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight,
                           kWidth * 3 / 4, kHeight, webrtc::kVideoRotation_0,
                           &frame2));
     EXPECT_TRUE(IsEqualWithCrop(frame2, *frame1, kWidth / 8, 0, 2));
   }
 
   // Test constructing an image from an I420 buffer, cropping top and bottom.
   void ConstructI420CropVertical() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight,
+    ASSERT_TRUE(LoadFrame(LoadSample(kImageFilename, kYuvExtension).get(),
+                          cricket::FOURCC_I420, kWidth, kHeight,
                           kWidth, kHeight * 3 / 4, webrtc::kVideoRotation_0,
                           &frame2));
     EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, 0, kHeight / 8, 0));
   }
 
   // Test constructing an image from I420 synonymous formats.
   void ConstructI420Aliases() {
     T frame1, frame2, frame3;
-    ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight,
+    ASSERT_TRUE(LoadFrame(LoadSample(kImageFilename, kYuvExtension),
+                          cricket::FOURCC_I420, kWidth, kHeight,
                           &frame1));
-    ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_IYUV, kWidth, kHeight,
+    ASSERT_TRUE(LoadFrame(kImageFilename, kYuvExtension,
+                          cricket::FOURCC_IYUV, kWidth, kHeight,
                           &frame2));
-    ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_YU12, kWidth, kHeight,
+    ASSERT_TRUE(LoadFrame(kImageFilename, kYuvExtension,
+                          cricket::FOURCC_YU12, kWidth, kHeight,
                           &frame3));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));
   }
 
   // Test constructing an image from an I420 MJPG buffer.
   void ConstructMjpgI420() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kJpeg420Filename,
+    ASSERT_TRUE(LoadFrame(kJpeg420Filename, kJpegExtension,
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 32));
   }
 
   // Test constructing an image from an I422 MJPG buffer.
   void ConstructMjpgI422() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kJpeg422Filename,
+    ASSERT_TRUE(LoadFrame(LoadSample(kJpeg422Filename, kJpegExtension).get(),
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 32));
   }
 
   // Test constructing an image from an I444 MJPG buffer.
   void ConstructMjpgI444() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kJpeg444Filename,
+    ASSERT_TRUE(LoadFrame(LoadSample(kJpeg444Filename, kJpegExtension),
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 32));
   }
 
   // Test constructing an image from an I444 MJPG buffer.
   void ConstructMjpgI411() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kJpeg411Filename,
+    ASSERT_TRUE(LoadFrame(kJpeg411Filename, kJpegExtension,
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsEqual(frame1, frame2, 32));
   }
 
   // Test constructing an image from an I400 MJPG buffer.
   // TODO(fbarchard): Stronger compare on chroma.  Compare agaisnt a grey image.
   void ConstructMjpgI400() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
-    ASSERT_TRUE(LoadFrame(kJpeg400Filename,
+    ASSERT_TRUE(LoadFrame(kJpeg400Filename, kJpegExtension,
                           cricket::FOURCC_MJPG, kWidth, kHeight, &frame2));
     EXPECT_TRUE(IsPlaneEqual("y", frame1.video_frame_buffer()->DataY(),
                              frame1.video_frame_buffer()->StrideY(),
                              frame2.video_frame_buffer()->DataY(),
                              frame2.video_frame_buffer()->StrideY(),
                              kWidth, kHeight, 32));
     EXPECT_TRUE(IsEqual(frame1, frame2, 128));
   }
 
   // Test constructing an image from an I420 MJPG buffer.
   void ValidateFrame(const char* name,
+                     const char* extension,
                      uint32_t fourcc,
                      int data_adjust,
                      int size_adjust,
                      bool expected_result) {
     T frame;
-    std::unique_ptr<rtc::MemoryStream> ms(LoadSample(name));
+    std::unique_ptr<rtc::MemoryStream> ms(LoadSample(name, extension));
     ASSERT_TRUE(ms.get() != NULL);
     const uint8_t* sample =
         reinterpret_cast<const uint8_t*>(ms.get()->GetBuffer());
     size_t sample_size;
     ms->GetSize(&sample_size);
     // Optional adjust size to test invalid size.
     size_t data_size = sample_size + data_adjust;
 
     // Allocate a buffer with end page aligned.
     const int kPadToHeapSized = 16 * 1024 * 1024;
     std::unique_ptr<uint8_t[]> page_buffer(
         new uint8_t[((data_size + kPadToHeapSized + 4095) & ~4095)]);
     uint8_t* data_ptr = page_buffer.get();
     if (!data_ptr) {
       LOG(LS_WARNING) << "Failed to allocate memory for ValidateFrame test.";
       EXPECT_FALSE(expected_result);  // NULL is okay if failure was expected.
       return;
     }
     data_ptr += kPadToHeapSized + (-(static_cast<int>(data_size)) & 4095);
     memcpy(data_ptr, sample, std::min(data_size, sample_size));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(expected_result, frame.Validate(fourcc, kWidth, kHeight,
                                                 data_ptr,
                                                 sample_size + size_adjust));
     }
   }
 
   // Test validate for I420 MJPG buffer.
   void ValidateMjpgI420() {
-    ValidateFrame(kJpeg420Filename, cricket::FOURCC_MJPG, 0, 0, true);
+    ValidateFrame(kJpeg420Filename, kJpegExtension,
+                  cricket::FOURCC_MJPG, 0, 0, true);
   }
 
   // Test validate for I422 MJPG buffer.
   void ValidateMjpgI422() {
-    ValidateFrame(kJpeg422Filename, cricket::FOURCC_MJPG, 0, 0, true);
+    ValidateFrame(kJpeg422Filename, kJpegExtension,
+                  cricket::FOURCC_MJPG, 0, 0, true);
   }
 
   // Test validate for I444 MJPG buffer.
   void ValidateMjpgI444() {
-    ValidateFrame(kJpeg444Filename, cricket::FOURCC_MJPG, 0, 0, true);
+    ValidateFrame(kJpeg444Filename, kJpegExtension,
+                  cricket::FOURCC_MJPG, 0, 0, true);
   }
 
   // Test validate for I411 MJPG buffer.
   void ValidateMjpgI411() {
-    ValidateFrame(kJpeg411Filename, cricket::FOURCC_MJPG, 0, 0, true);
+    ValidateFrame(kJpeg411Filename, kJpegExtension,
+                  cricket::FOURCC_MJPG, 0, 0, true);
   }
 
   // Test validate for I400 MJPG buffer.
   void ValidateMjpgI400() {
-    ValidateFrame(kJpeg400Filename, cricket::FOURCC_MJPG, 0, 0, true);
+    ValidateFrame(kJpeg400Filename, kJpegExtension,
+                  cricket::FOURCC_MJPG, 0, 0, true);
   }
 
   // Test validate for I420 buffer.
   void ValidateI420() {
-    ValidateFrame(kImageFilename, cricket::FOURCC_I420, 0, 0, true);
+    ValidateFrame(kImageFilename, kYuvExtension,
+                  cricket::FOURCC_I420, 0, 0, true);
   }
 
   // Test validate for I420 buffer where size is too small
   void ValidateI420SmallSize() {
-    ValidateFrame(kImageFilename, cricket::FOURCC_I420, 0, -16384, false);
+    ValidateFrame(kImageFilename, kYuvExtension,
+                  cricket::FOURCC_I420, 0, -16384, false);
   }
 
   // Test validate for I420 buffer where size is too large (16 MB)
   // Will produce warning but pass.
   void ValidateI420LargeSize() {
-    ValidateFrame(kImageFilename, cricket::FOURCC_I420, 16000000, 16000000,
+    ValidateFrame(kImageFilename, kYuvExtension,
+                  cricket::FOURCC_I420, 16000000, 16000000,
                   true);
   }
 
   // Test validate for I420 buffer where size is 1 GB (not reasonable).
   void ValidateI420HugeSize() {
 #ifndef WIN32  // TODO(fbarchard): Reenable when fixing bug 9603762.
-    ValidateFrame(kImageFilename, cricket::FOURCC_I420, 1000000000u,
+    ValidateFrame(kImageFilename, kYuvExtension,
+                  cricket::FOURCC_I420, 1000000000u,
                   1000000000u, false);
 #endif
   }
 
   // The following test that Validate crashes if the size is greater than the
   // actual buffer size.
   // TODO(fbarchard): Consider moving a filter into the capturer/plugin.
 #if defined(_MSC_VER) && !defined(NDEBUG)
   int ExceptionFilter(unsigned int code, struct _EXCEPTION_POINTERS *ep) {
     if (code == EXCEPTION_ACCESS_VIOLATION) {
       LOG(LS_INFO) << "Caught EXCEPTION_ACCESS_VIOLATION as expected.";
       return EXCEPTION_EXECUTE_HANDLER;
     } else {
       LOG(LS_INFO) << "Did not catch EXCEPTION_ACCESS_VIOLATION.  Unexpected.";
       return EXCEPTION_CONTINUE_SEARCH;
     }
   }
 
   // Test validate fails for truncated MJPG data buffer.  If ValidateFrame
   // crashes the exception handler will return and unittest passes with OK.
   void ValidateMjpgI420InvalidSize() {
     __try {
-      ValidateFrame(kJpeg420Filename, cricket::FOURCC_MJPG, -16384, 0, false);
+      ValidateFrame(kJpeg420Filename,  kJpegExtension,
+                    cricket::FOURCC_MJPG, -16384, 0, false);
       FAIL() << "Validate was expected to cause EXCEPTION_ACCESS_VIOLATION.";
     } __except(ExceptionFilter(GetExceptionCode(), GetExceptionInformation())) {
       return;  // Successfully crashed in ValidateFrame.
     }
   }
 
   // Test validate fails for truncated I420 buffer.
   void ValidateI420InvalidSize() {
     __try {
-      ValidateFrame(kImageFilename, cricket::FOURCC_I420, -16384, 0, false);
+      ValidateFrame(kImageFilename, kYuvExtension,
+                    cricket::FOURCC_I420, -16384, 0, false);
       FAIL() << "Validate was expected to cause EXCEPTION_ACCESS_VIOLATION.";
     } __except(ExceptionFilter(GetExceptionCode(), GetExceptionInformation())) {
       return;  // Successfully crashed in ValidateFrame.
     }
   }
 #endif
 
   // Test constructing an image from a YUY2 buffer (and synonymous formats).
   void ConstructYuy2Aliases() {
     T frame1, frame2, frame3, frame4;
@@ skipping 502 matching lines @@
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
     const T* const_source = source.get();
     EXPECT_EQ(const_source->video_frame_buffer(), target->video_frame_buffer());
   }
 
   int repeat_;
 };
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_