Remove duplicate CPU detection code; use base::CPU instead.

media/base/yuv_convert_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 "base/base_paths.h"
+#include "base/cpu.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
-#include "media/base/cpu_features.h"
 #include "media/base/djb2.h"
 #include "media/base/simd/convert_rgb_to_yuv.h"
 #include "media/base/simd/convert_yuv_to_rgb.h"
 #include "media/base/simd/filter_yuv.h"
 #include "media/base/yuv_convert.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 
 // Size of raw image.
 static const int kSourceWidth = 640;
@@ skipping 430 matching lines @@
     if (next_sub_rect & 2)
       sub_rect.set_y(sub_rect.y() + sub_rect.height() / 2);
     sub_rect.set_width(sub_rect.width() / 2);
     sub_rect.set_height(sub_rect.height() / 2);
     next_sub_rect++;
   }
 }
 
 #if !defined(ARCH_CPU_ARM_FAMILY)
 TEST(YUVConvertTest, RGB32ToYUV_SSE2_MatchReference) {
-  if (!media::hasSSE2()) {
+  base::CPU cpu;
+  if (!cpu.has_sse2()) {
     LOG(WARNING) << "System doesn't support SSE2, test not executed.";
     return;
   }
 
   // Allocate all surfaces.
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes(new uint8[kRGBSize]);
   scoped_array<uint8> yuv_converted_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> yuv_reference_bytes(new uint8[kYUV12Size]);
 
@@ skipping 65 matching lines @@
     if (diff < 0)
       diff = -diff;
     error += diff;
   }
 
   // Make sure there's no difference from the reference.
   EXPECT_EQ(0, error);
 }
 
 TEST(YUVConvertTest, ConvertYUVToRGB32Row_MMX) {
-  if (!media::hasMMX()) {
+  base::CPU cpu;
+  if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_array<uint8> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   ConvertYUVToRGB32Row_C(yuv_bytes.get(),
                          yuv_bytes.get() + kSourceUOffset,
                          yuv_bytes.get() + kSourceVOffset,
                          rgb_bytes_reference.get(),
                          kWidth);
   ConvertYUVToRGB32Row_MMX(yuv_bytes.get(),
                            yuv_bytes.get() + kSourceUOffset,
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_bytes_converted.get(),
                            kWidth);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, ConvertYUVToRGB32Row_SSE) {
-  if (!media::hasSSE()) {
+  base::CPU cpu;
+  if (!cpu.has_sse()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_array<uint8> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
   ConvertYUVToRGB32Row_C(yuv_bytes.get(),
                          yuv_bytes.get() + kSourceUOffset,
                          yuv_bytes.get() + kSourceVOffset,
                          rgb_bytes_reference.get(),
                          kWidth);
   ConvertYUVToRGB32Row_SSE(yuv_bytes.get(),
                            yuv_bytes.get() + kSourceUOffset,
                            yuv_bytes.get() + kSourceVOffset,
                            rgb_bytes_converted.get(),
                            kWidth);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, ScaleYUVToRGB32Row_MMX) {
-  if (!media::hasMMX()) {
+  base::CPU cpu;
+  if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_array<uint8> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
@@ skipping 10 matching lines @@
                          rgb_bytes_converted.get(),
                          kWidth,
                          kSourceDx);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, ScaleYUVToRGB32Row_SSE) {
-  if (!media::hasSSE()) {
+  base::CPU cpu;
+  if (!cpu.has_sse()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_array<uint8> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
@@ skipping 10 matching lines @@
                          rgb_bytes_converted.get(),
                          kWidth,
                          kSourceDx);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX) {
-  if (!media::hasMMX()) {
+  base::CPU cpu;
+  if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_array<uint8> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
@@ skipping 10 matching lines @@
                                rgb_bytes_converted.get(),
                                kWidth,
                                kSourceDx);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_SSE) {
-  if (!media::hasSSE()) {
+  base::CPU cpu;
+  if (!cpu.has_sse()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> yuv_bytes(new uint8[kYUV12Size]);
   scoped_array<uint8> rgb_bytes_reference(new uint8[kRGBSize]);
   scoped_array<uint8> rgb_bytes_converted(new uint8[kRGBSize]);
   ReadYV12Data(&yuv_bytes);
 
   const int kWidth = 167;
@@ skipping 25 matching lines @@
 
   media::FilterYUVRows_C(dst.get(), src.get(), src.get(), 1, 255);
 
   EXPECT_EQ(255u, dst[0]);
   for (int i = 1; i < 16; ++i) {
     EXPECT_EQ(0u, dst[i]) << " not equal at " << i;
   }
 }
 
 TEST(YUVConvertTest, FilterYUVRows_MMX_OutOfBounds) {
-  if (!media::hasMMX()) {
+  base::CPU cpu;
+  if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> src(new uint8[16]);
   scoped_array<uint8> dst(new uint8[16]);
 
   memset(src.get(), 0xff, 16);
   memset(dst.get(), 0, 16);
 
   media::FilterYUVRows_MMX(dst.get(), src.get(), src.get(), 1, 255);
   media::EmptyRegisterState();
 
   EXPECT_EQ(255u, dst[0]);
   for (int i = 1; i < 16; ++i) {
     EXPECT_EQ(0u, dst[i]);
   }
 }
 
 TEST(YUVConvertTest, FilterYUVRows_SSE2_OutOfBounds) {
-  if (!media::hasSSE2()) {
+  base::CPU cpu;
+  if (!cpu.has_sse2()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   scoped_array<uint8> src(new uint8[16]);
   scoped_array<uint8> dst(new uint8[16]);
 
   memset(src.get(), 0xff, 16);
   memset(dst.get(), 0, 16);
 
   media::FilterYUVRows_SSE2(dst.get(), src.get(), src.get(), 1, 255);
 
   EXPECT_EQ(255u, dst[0]);
   for (int i = 1; i < 16; ++i) {
     EXPECT_EQ(0u, dst[i]);
   }
 }
 
 TEST(YUVConvertTest, FilterYUVRows_MMX_UnalignedDestination) {
-  if (!media::hasMMX()) {
+  base::CPU cpu;
+  if (!cpu.has_mmx()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   const int kSize = 32;
   scoped_array<uint8> src(new uint8[kSize]);
   scoped_array<uint8> dst_sample(new uint8[kSize]);
   scoped_array<uint8> dst(new uint8[kSize]);
 
   memset(dst_sample.get(), 0, kSize);
   memset(dst.get(), 0, kSize);
   for (int i = 0; i < kSize; ++i)
     src[i] = 100 + i;
 
   media::FilterYUVRows_C(dst_sample.get(),
                          src.get(), src.get(), 17, 128);
 
   // Generate an unaligned output address.
   uint8* dst_ptr =
       reinterpret_cast<uint8*>(
           (reinterpret_cast<uintptr_t>(dst.get() + 8) & ~7) + 1);
   media::FilterYUVRows_MMX(dst_ptr, src.get(), src.get(), 17, 128);
   media::EmptyRegisterState();
 
   EXPECT_EQ(0, memcmp(dst_sample.get(), dst_ptr, 17));
 }
 
 TEST(YUVConvertTest, FilterYUVRows_SSE2_UnalignedDestination) {
-  if (!media::hasSSE2()) {
+  base::CPU cpu;
+  if (!cpu.has_sse2()) {
     LOG(WARNING) << "System not supported. Test skipped.";
     return;
   }
 
   const int kSize = 64;
   scoped_array<uint8> src(new uint8[kSize]);
   scoped_array<uint8> dst_sample(new uint8[kSize]);
   scoped_array<uint8> dst(new uint8[kSize]);
 
   memset(dst_sample.get(), 0, kSize);
@@ skipping 64 matching lines @@
                                    kSourceDx);
   media::EmptyRegisterState();
   EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
                       rgb_bytes_converted.get(),
                       kWidth * kBpp));
 }
 
 #endif  // defined(ARCH_CPU_X86_64)
 
 #endif  // defined(ARCH_CPU_X86_FAMILY)