Delete media/base/yuv_convert and dependents. Prefer libyuv.

media/base/video_frame_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.
 
 #include "media/base/video_frame.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
-#include "media/base/yuv_convert.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/libyuv/include/libyuv.h"
 
 namespace media {
 
 using base::MD5DigestToBase16;
 
 // Helper function that initializes a YV12 frame with white and black scan
 // lines based on the |white_to_black| parameter.  If 0, then the entire
 // frame will be black, if 1 then the entire frame will be white.
 void InitializeYV12Frame(VideoFrame* frame, double white_to_black) {
   EXPECT_EQ(PIXEL_FORMAT_YV12, frame->format());
@@ skipping 28 matching lines @@
   ASSERT_EQ(
       yv12_frame->coded_size().height() & (VideoFrame::kFrameSizeAlignment - 1),
       0);
 
   size_t bytes_per_row = yv12_frame->coded_size().width() * 4u;
   uint8_t* rgb_data = reinterpret_cast<uint8_t*>(
       base::AlignedAlloc(bytes_per_row * yv12_frame->coded_size().height() +
                              VideoFrame::kFrameSizePadding,
                          VideoFrame::kFrameAddressAlignment));
 
-  media::ConvertYUVToRGB32(yv12_frame->data(VideoFrame::kYPlane),
-                           yv12_frame->data(VideoFrame::kUPlane),
-                           yv12_frame->data(VideoFrame::kVPlane),
-                           rgb_data,
-                           yv12_frame->coded_size().width(),
-                           yv12_frame->coded_size().height(),
-                           yv12_frame->stride(VideoFrame::kYPlane),
-                           yv12_frame->stride(VideoFrame::kUPlane),
-                           bytes_per_row,
-                           media::YV12);
+  libyuv::I420ToARGB(yv12_frame->data(VideoFrame::kYPlane),
+                     yv12_frame->stride(VideoFrame::kYPlane),
+                     yv12_frame->data(VideoFrame::kUPlane),
+                     yv12_frame->stride(VideoFrame::kUPlane),
+                     yv12_frame->data(VideoFrame::kVPlane),
+                     yv12_frame->stride(VideoFrame::kVPlane), rgb_data,
+                     bytes_per_row, yv12_frame->coded_size().width(),
+                     yv12_frame->coded_size().height());
 
   for (int row = 0; row < yv12_frame->coded_size().height(); ++row) {
     uint32_t* rgb_row_data =
         reinterpret_cast<uint32_t*>(rgb_data + (bytes_per_row * row));
     for (int col = 0; col < yv12_frame->coded_size().width(); ++col) {
       SCOPED_TRACE(base::StringPrintf("Checking (%d, %d)", row, col));
       EXPECT_EQ(expect_rgb_color, rgb_row_data[col]);
     }
   }
 
@@ skipping 475 matching lines @@
 
   for (int i = 0; i < VideoFrameMetadata::NUM_KEYS; ++i) {
     const VideoFrameMetadata::Key key = static_cast<VideoFrameMetadata::Key>(i);
     int value = -1;
     EXPECT_TRUE(result.GetInteger(key, &value));
     EXPECT_EQ(i, value);
   }
 }
 
 }  // namespace media