Test X11 header pollution

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>
 #include <string.h>
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
-#include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/jpeg_parser.h"
+#include "media/gpu/video_accelerator_unittest_helpers.h"
 #include "media/video/jpeg_decode_accelerator.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
-#include "content/common/gpu/media/v4l2_device.h"
-#include "content/common/gpu/media/v4l2_jpeg_decode_accelerator.h"
+#include "media/gpu/v4l2_device.h"
+#include "media/gpu/v4l2_jpeg_decode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
-#include "content/common/gpu/media/vaapi_jpeg_decode_accelerator.h"
-#include "content/common/gpu/media/vaapi_wrapper.h"
+#include "media/gpu/vaapi_jpeg_decode_accelerator.h"
+#include "media/gpu/vaapi_wrapper.h"
 #endif
 #endif
 
 using media::JpegDecodeAccelerator;
 
-namespace content {
+namespace media {
 namespace {
 
 // Default test image file.
 const base::FilePath::CharType* kDefaultJpegFilename =
     FILE_PATH_LITERAL("peach_pi-1280x720.jpg");
 // Decide to save decode results to files or not. Output files will be saved
 // in the same directory with unittest. File name is like input file but
 // changing the extension to "yuv".
 bool g_save_to_file = false;
 // Threshold for mean absolute difference of hardware and software decode.
@@ skipping 65 matching lines @@
   // Mapped memory of output buffer from hardware decoder.
   std::unique_ptr<base::SharedMemory> hw_out_shm_;
   // Mapped memory of output buffer from software decoder.
   std::unique_ptr<base::SharedMemory> sw_out_shm_;
 
   DISALLOW_COPY_AND_ASSIGN(JpegClient);
 };
 
 JpegClient::JpegClient(const std::vector<TestImageFile*>& test_image_files,
                        ClientStateNotification<ClientState>* note)
-    : test_image_files_(test_image_files), state_(CS_CREATED), note_(note) {
-}
+    : test_image_files_(test_image_files), state_(CS_CREATED), note_(note) {}
 
-JpegClient::~JpegClient() {
-}
+JpegClient::~JpegClient() {}
 
 void JpegClient::CreateJpegDecoder() {
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   decoder_.reset(
       new VaapiJpegDecodeAccelerator(base::ThreadTaskRunnerHandle::Get()));
 #elif defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device =
       V4L2Device::Create(V4L2Device::kJpegDecoder);
   if (!device.get()) {
     LOG(ERROR) << "V4L2Device::Create failed";
@@ skipping 24 matching lines @@
   }
   if (g_save_to_file) {
     SaveToFile(bitstream_buffer_id);
   }
 
   double difference = GetMeanAbsoluteDifference(bitstream_buffer_id);
   if (difference <= kDecodeSimilarityThreshold) {
     SetState(CS_DECODE_PASS);
   } else {
     LOG(ERROR) << "The mean absolute difference between software and hardware "
-                  "decode is " << difference;
+                  "decode is "
+               << difference;
     SetState(CS_ERROR);
   }
 }
 
 void JpegClient::NotifyError(int32_t bitstream_buffer_id,
                              JpegDecodeAccelerator::Error error) {
   LOG(ERROR) << "Notifying of error " << error << " for buffer id "
              << bitstream_buffer_id;
   SetState(CS_ERROR);
 }
@@ skipping 56 matching lines @@
   TestImageFile* image_file = test_image_files_[bitstream_buffer_id];
 
   PrepareMemory(bitstream_buffer_id);
 
   base::SharedMemoryHandle dup_handle;
   dup_handle = base::SharedMemory::DuplicateHandle(in_shm_->handle());
   media::BitstreamBuffer bitstream_buffer(bitstream_buffer_id, dup_handle,
                                           image_file->data_str.size());
   scoped_refptr<media::VideoFrame> out_frame_ =
       media::VideoFrame::WrapExternalSharedMemory(
-          media::PIXEL_FORMAT_I420,
-          image_file->visible_size,
-          gfx::Rect(image_file->visible_size),
-          image_file->visible_size,
-          static_cast<uint8_t*>(hw_out_shm_->memory()),
-          image_file->output_size,
-          hw_out_shm_->handle(),
-          0,
-          base::TimeDelta());
+          media::PIXEL_FORMAT_I420, image_file->visible_size,
+          gfx::Rect(image_file->visible_size), image_file->visible_size,
+          static_cast<uint8_t*>(hw_out_shm_->memory()), image_file->output_size,
+          hw_out_shm_->handle(), 0, base::TimeDelta());
   LOG_ASSERT(out_frame_.get());
   decoder_->Decode(bitstream_buffer, out_frame_);
 }
 
 bool JpegClient::GetSoftwareDecodeResult(int32_t bitstream_buffer_id) {
   media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
   TestImageFile* image_file = test_image_files_[bitstream_buffer_id];
 
   uint8_t* yplane = static_cast<uint8_t*>(sw_out_shm_->memory());
   uint8_t* uplane =
       yplane +
       media::VideoFrame::PlaneSize(format, media::VideoFrame::kYPlane,
-                                   image_file->visible_size).GetArea();
+                                   image_file->visible_size)
+          .GetArea();
   uint8_t* vplane =
       uplane +
       media::VideoFrame::PlaneSize(format, media::VideoFrame::kUPlane,
-                                   image_file->visible_size).GetArea();
+                                   image_file->visible_size)
+          .GetArea();
   int yplane_stride = image_file->visible_size.width();
   int uv_plane_stride = yplane_stride / 2;
 
   if (libyuv::ConvertToI420(
-          static_cast<uint8_t*>(in_shm_->memory()),
-          image_file->data_str.size(),
-          yplane,
-          yplane_stride,
-          uplane,
-          uv_plane_stride,
-          vplane,
-          uv_plane_stride,
-          0,
-          0,
-          image_file->visible_size.width(),
-          image_file->visible_size.height(),
-          image_file->visible_size.width(),
-          image_file->visible_size.height(),
-          libyuv::kRotate0,
+          static_cast<uint8_t*>(in_shm_->memory()), image_file->data_str.size(),
+          yplane, yplane_stride, uplane, uv_plane_stride, vplane,
+          uv_plane_stride, 0, 0, image_file->visible_size.width(),
+          image_file->visible_size.height(), image_file->visible_size.width(),
+          image_file->visible_size.height(), libyuv::kRotate0,
           libyuv::FOURCC_MJPG) != 0) {
     LOG(ERROR) << "Software decode " << image_file->filename << " failed.";
     return false;
   }
   return true;
 }
 
 class JpegDecodeAcceleratorTestEnvironment : public ::testing::Environment {
  public:
   JpegDecodeAcceleratorTestEnvironment(
       const base::FilePath::CharType* jpeg_filenames) {
     user_jpeg_filenames_ =
-        jpeg_filenames ? jpeg_filenames: kDefaultJpegFilename;
+        jpeg_filenames ? jpeg_filenames : kDefaultJpegFilename;
   }
   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);
 
@@ skipping 87 matching lines @@
     return false;
   }
 
   LOG_ASSERT(base::CreateTemporaryFile(filename));
   EXPECT_TRUE(base::AppendToFile(
       *filename, reinterpret_cast<char*>(&encoded[0]), encoded.size()));
   return true;
 }
 
 void JpegDecodeAcceleratorTestEnvironment::ReadTestJpegImage(
-    base::FilePath& input_file, TestImageFile* image_data) {
+    base::FilePath& input_file,
+    TestImageFile* image_data) {
   ASSERT_TRUE(base::ReadFileToString(input_file, &image_data->data_str));
 
   ASSERT_TRUE(media::ParseJpegPicture(
       reinterpret_cast<const uint8_t*>(image_data->data_str.data()),
-                                       image_data->data_str.size(),
-      &image_data->parse_result));
+      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 = media::VideoFrame::AllocationSize(
       media::PIXEL_FORMAT_I420, image_data->visible_size);
 }
 
 class JpegDecodeAcceleratorTest : public ::testing::Test {
  protected:
   JpegDecodeAcceleratorTest() {}
@@ skipping 23 matching lines @@
     decoder_thread.task_runner()->PostTask(
         FROM_HERE, base::Bind(&JpegClient::CreateJpegDecoder,
                               base::Unretained(clients.back())));
     ASSERT_EQ(notes[i]->Wait(), CS_INITIALIZED);
   }
 
   for (size_t index = 0; index < test_image_files_.size(); index++) {
     for (size_t i = 0; i < num_concurrent_decoders; i++) {
       decoder_thread.task_runner()->PostTask(
           FROM_HERE, base::Bind(&JpegClient::StartDecode,
-                                base::Unretained(clients[i]),
-                                index));
+                                base::Unretained(clients[i]), index));
     }
     for (size_t i = 0; i < num_concurrent_decoders; i++) {
       ASSERT_EQ(notes[i]->Wait(), expected_status_[index]);
     }
   }
 
   for (size_t i = 0; i < num_concurrent_decoders; i++) {
     decoder_thread.task_runner()->PostTask(
         FROM_HERE, base::Bind(&JpegClient::DestroyJpegDecoder,
                               base::Unretained(clients[i])));
@@ skipping 51 matching lines @@
 
 TEST_F(JpegDecodeAcceleratorTest, KeepDecodeAfterFailure) {
   test_image_files_.push_back(g_env->image_data_invalid_.get());
   test_image_files_.push_back(g_env->image_data_1280x720_default_.get());
   expected_status_.push_back(CS_ERROR);
   expected_status_.push_back(CS_DECODE_PASS);
   TestDecode(1);
 }
 
 }  // namespace
-}  // namespace content
+}  // namespace media
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   base::CommandLine::Init(argc, argv);
   base::ShadowingAtExitManager at_exit_manager;
 
   // 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);
 
   const base::FilePath::CharType* jpeg_filenames = nullptr;
   base::CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (base::CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     // jpeg_filenames can include one or many files and use ';' as delimiter.
     if (it->first == "jpeg_filenames") {
       jpeg_filenames = it->second.c_str();
       continue;
     }
     if (it->first == "save_to_file") {
-      content::g_save_to_file = true;
+      media::g_save_to_file = true;
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  content::VaapiWrapper::PreSandboxInitialization();
+  media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
-  content::g_env =
-      reinterpret_cast<content::JpegDecodeAcceleratorTestEnvironment*>(
-          testing::AddGlobalTestEnvironment(
-              new content::JpegDecodeAcceleratorTestEnvironment(
-                  jpeg_filenames)));
+  media::g_env = reinterpret_cast<media::JpegDecodeAcceleratorTestEnvironment*>(
+      testing::AddGlobalTestEnvironment(
+          new media::JpegDecodeAcceleratorTestEnvironment(jpeg_filenames)));
 
   return RUN_ALL_TESTS();
 }