Test X11 header pollution

media/gpu/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 12 matching lines @@
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
-#include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
 #include "media/base/test_data_util.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/h264_parser.h"
 #include "media/filters/ivf_parser.h"
+#include "media/gpu/video_accelerator_unittest_helpers.h"
 #include "media/video/fake_video_encode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_ARMEL) || (defined(USE_OZONE) && defined(USE_V4L2_CODEC))
-#include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
+#include "media/gpu/v4l2_video_encode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
-#include "content/common/gpu/media/vaapi_video_encode_accelerator.h"
-#include "content/common/gpu/media/vaapi_wrapper.h"
+#include "media/gpu/vaapi_video_encode_accelerator.h"
+#include "media/gpu/vaapi_wrapper.h"
 // Status has been defined as int in Xlib.h.
 #undef Status
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 #elif defined(OS_MACOSX)
-#include "content/common/gpu/media/vt_video_encode_accelerator_mac.h"
+#include "media/gpu/vt_video_encode_accelerator_mac.h"
 #else
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
 using media::VideoEncodeAccelerator;
 
-namespace content {
+namespace media {
 namespace {
 
 const media::VideoPixelFormat kInputFormat = media::PIXEL_FORMAT_I420;
 
 // The absolute differences between original frame and decoded frame usually
 // ranges aroud 1 ~ 7. So we pick 10 as an extreme value to detect abnormal
 // decoded frames.
 const double kDecodeSimilarityThreshold = 10.0;
 
 // Arbitrarily chosen to add some depth to the pipeline.
@@ skipping 243 matching lines @@
       test_stream->mapped_aligned_in_file.Initialize(std::move(dest_file)));
   // Assert that memory mapped of file starts at 64 byte boundary. So each
   // plane of frames also start at 64 byte boundary.
 
   ASSERT_EQ(
       reinterpret_cast<off_t>(test_stream->mapped_aligned_in_file.data()) & 63,
       0)
       << "File should be mapped at a 64 byte boundary";
 
   LOG_ASSERT(test_stream->mapped_aligned_in_file.length() %
-               test_stream->aligned_buffer_size == 0U)
+                 test_stream->aligned_buffer_size ==
+             0U)
       << "Stream byte size is not a product of calculated frame byte size";
   LOG_ASSERT(test_stream->num_frames > 0UL);
 }
 
 // Parse |data| into its constituent parts, set the various output fields
 // accordingly, read in video stream, and store them to |test_streams|.
 static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
                                        ScopedVector<TestStream>* test_streams) {
   // Split the string to individual test stream data.
-  std::vector<base::FilePath::StringType> test_streams_data = base::SplitString(
-      data, base::FilePath::StringType(1, ';'),
-      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<base::FilePath::StringType> test_streams_data =
+      base::SplitString(data, base::FilePath::StringType(1, ';'),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   LOG_ASSERT(test_streams_data.size() >= 1U) << data;
 
   // Parse each test stream data and read the input file.
   for (size_t index = 0; index < test_streams_data.size(); ++index) {
     std::vector<base::FilePath::StringType> fields = base::SplitString(
         test_streams_data[index], base::FilePath::StringType(1, ':'),
         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     LOG_ASSERT(fields.size() >= 4U) << data;
     LOG_ASSERT(fields.size() <= 9U) << data;
     TestStream* test_stream = new TestStream();
@@ skipping 11 matching lines @@
     LOG_ASSERT(result);
     LOG_ASSERT(profile > media::VIDEO_CODEC_PROFILE_UNKNOWN);
     LOG_ASSERT(profile <= media::VIDEO_CODEC_PROFILE_MAX);
     test_stream->requested_profile =
         static_cast<media::VideoCodecProfile>(profile);
 
     if (fields.size() >= 5 && !fields[4].empty())
       test_stream->out_filename = fields[4];
 
     if (fields.size() >= 6 && !fields[5].empty())
-      LOG_ASSERT(base::StringToUint(fields[5],
-          &test_stream->requested_bitrate));
+      LOG_ASSERT(
+          base::StringToUint(fields[5], &test_stream->requested_bitrate));
 
     if (fields.size() >= 7 && !fields[6].empty())
-      LOG_ASSERT(base::StringToUint(fields[6],
-          &test_stream->requested_framerate));
+      LOG_ASSERT(
+          base::StringToUint(fields[6], &test_stream->requested_framerate));
 
     if (fields.size() >= 8 && !fields[7].empty()) {
-      LOG_ASSERT(base::StringToUint(fields[7],
-                               &test_stream->requested_subsequent_bitrate));
+      LOG_ASSERT(base::StringToUint(
+          fields[7], &test_stream->requested_subsequent_bitrate));
     }
 
     if (fields.size() >= 9 && !fields[8].empty()) {
-      LOG_ASSERT(base::StringToUint(fields[8],
-                               &test_stream->requested_subsequent_framerate));
+      LOG_ASSERT(base::StringToUint(
+          fields[8], &test_stream->requested_subsequent_framerate));
     }
     test_streams->push_back(test_stream);
   }
 }
 
 // Basic test environment shared across multiple test cases. We only need to
 // setup it once for all test cases.
 // It helps
 // - maintain test stream data and other test settings.
 // - clean up temporary aligned files.
@@ skipping 138 matching lines @@
     ASSERT_EQ(media::H264Parser::kOk, result);
 
     bool keyframe = false;
 
     switch (nalu.nal_unit_type) {
       case media::H264NALU::kIDRSlice:
         ASSERT_TRUE(seen_sps_);
         ASSERT_TRUE(seen_pps_);
         seen_idr_ = true;
         keyframe = true;
-        // fallthrough
+      // fallthrough
       case media::H264NALU::kNonIDRSlice: {
         ASSERT_TRUE(seen_idr_);
         if (!frame_cb_.Run(keyframe))
           return;
         break;
       }
 
       case media::H264NALU::kSPS: {
         int sps_id;
         ASSERT_EQ(media::H264Parser::kOk, h264_parser_.ParseSPS(&sps_id));
@@ skipping 11 matching lines @@
 
       default:
         break;
     }
   }
 }
 
 class VP8Validator : public StreamValidator {
  public:
   explicit VP8Validator(const FrameFoundCallback& frame_cb)
-      : StreamValidator(frame_cb),
-        seen_keyframe_(false) {}
+      : StreamValidator(frame_cb), seen_keyframe_(false) {}
 
   void ProcessStreamBuffer(const uint8_t* stream, size_t size) override;
 
  private:
   // Have we already got a keyframe in the stream?
   bool seen_keyframe_;
 };
 
 void VP8Validator::ProcessStreamBuffer(const uint8_t* stream, size_t size) {
   bool keyframe = !(stream[0] & 0x01);
@@ skipping 451 matching lines @@
     // Without it, AppendToFile() will not work.
     EXPECT_EQ(0, base::WriteFile(out_filename, NULL, 0));
   }
 
   // Initialize the parameters of the test streams.
   UpdateTestStreamData(mid_stream_bitrate_switch, mid_stream_framerate_switch);
 
   thread_checker_.DetachFromThread();
 }
 
-VEAClient::~VEAClient() { LOG_ASSERT(!has_encoder()); }
+VEAClient::~VEAClient() {
+  LOG_ASSERT(!has_encoder());
+}
 
 std::unique_ptr<media::VideoEncodeAccelerator> VEAClient::CreateFakeVEA() {
   std::unique_ptr<media::VideoEncodeAccelerator> encoder;
   if (g_fake_encoder) {
     encoder.reset(new media::FakeVideoEncodeAccelerator(
         scoped_refptr<base::SingleThreadTaskRunner>(
             base::ThreadTaskRunnerHandle::Get())));
   }
   return encoder;
 }
 
 std::unique_ptr<media::VideoEncodeAccelerator> VEAClient::CreateV4L2VEA() {
   std::unique_ptr<media::VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && (defined(ARCH_CPU_ARMEL) || \
-    (defined(USE_OZONE) && defined(USE_V4L2_CODEC)))
+                             (defined(USE_OZONE) && defined(USE_V4L2_CODEC)))
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
   if (device)
     encoder.reset(new V4L2VideoEncodeAccelerator(device));
 #endif
   return encoder;
 }
 
 std::unique_ptr<media::VideoEncodeAccelerator> VEAClient::CreateVaapiVEA() {
   std::unique_ptr<media::VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
@@ skipping 18 matching lines @@
       CreateFakeVEA(), CreateV4L2VEA(), CreateVaapiVEA(), CreateVTVEA()};
 
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
 
   for (size_t i = 0; i < arraysize(encoders); ++i) {
     if (!encoders[i])
       continue;
     encoder_ = std::move(encoders[i]);
     SetState(CS_ENCODER_SET);
-    if (encoder_->Initialize(kInputFormat,
-                             test_stream_->visible_size,
+    if (encoder_->Initialize(kInputFormat, test_stream_->visible_size,
                              test_stream_->requested_profile,
-                             requested_bitrate_,
-                             this)) {
+                             requested_bitrate_, this)) {
       SetStreamParameters(requested_bitrate_, requested_framerate_);
       SetState(CS_INITIALIZED);
 
       if (verify_output_ && !g_fake_encoder)
         quality_validator_.reset(new VideoFrameQualityValidator(
             test_stream_->requested_profile,
             base::Bind(&VEAClient::DecodeCompleted, base::Unretained(this)),
             base::Bind(&VEAClient::DecodeFailed, base::Unretained(this))));
       return;
     }
@@ skipping 229 matching lines @@
 }
 
 scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(
     off_t position,
     int32_t* input_id) {
   CHECK_LE(position + test_stream_->aligned_buffer_size,
            test_stream_->mapped_aligned_in_file.length());
 
   scoped_refptr<media::VideoFrame> frame = CreateFrame(position);
   EXPECT_TRUE(frame);
-  frame->AddDestructionObserver(
-          media::BindToCurrentLoop(
-              base::Bind(&VEAClient::InputNoLongerNeededCallback,
-                         base::Unretained(this),
-                         next_input_id_)));
+  frame->AddDestructionObserver(media::BindToCurrentLoop(
+      base::Bind(&VEAClient::InputNoLongerNeededCallback,
+                 base::Unretained(this), next_input_id_)));
 
   LOG_ASSERT(inputs_at_client_.insert(next_input_id_).second);
 
   *input_id = next_input_id_++;
   return frame;
 }
 
 void VEAClient::OnInputTimer() {
   if (!has_encoder() || state_ != CS_ENCODING)
     input_timer_.reset();
@@ skipping 47 matching lines @@
 void VEAClient::FeedEncoderWithOutput(base::SharedMemory* shm) {
   if (!has_encoder())
     return;
 
   if (state_ != CS_ENCODING)
     return;
 
   base::SharedMemoryHandle dup_handle;
   LOG_ASSERT(shm->ShareToProcess(base::GetCurrentProcessHandle(), &dup_handle));
 
-  media::BitstreamBuffer bitstream_buffer(
-      next_output_buffer_id_++, dup_handle, output_buffer_size_);
-  LOG_ASSERT(output_buffers_at_client_.insert(
-      std::make_pair(bitstream_buffer.id(), shm)).second);
+  media::BitstreamBuffer bitstream_buffer(next_output_buffer_id_++, dup_handle,
+                                          output_buffer_size_);
+  LOG_ASSERT(output_buffers_at_client_
+                 .insert(std::make_pair(bitstream_buffer.id(), shm))
+                 .second);
   encoder_->UseOutputBitstreamBuffer(bitstream_buffer);
 }
 
 bool VEAClient::HandleEncodedFrame(bool keyframe) {
   // This would be a bug in the test, which should not ignore false
   // return value from this method.
   LOG_ASSERT(num_encoded_frames_ <= num_frames_to_encode_);
 
   last_frame_ready_time_ = base::TimeTicks::Now();
 
@@ skipping 73 matching lines @@
   if (test_perf_)
     EXPECT_GE(frames_per_second(), kMinPerfFPS);
 }
 
 void VEAClient::VerifyStreamProperties() {
   LOG_ASSERT(num_frames_since_last_check_ > 0UL);
   LOG_ASSERT(encoded_stream_size_since_last_check_ > 0UL);
   unsigned int bitrate = encoded_stream_size_since_last_check_ * 8 *
                          current_framerate_ / num_frames_since_last_check_;
   DVLOG(1) << "Current chunk's bitrate: " << bitrate
-           << " (expected: " << current_requested_bitrate_
-           << " @ " << current_framerate_ << " FPS,"
+           << " (expected: " << current_requested_bitrate_ << " @ "
+           << current_framerate_ << " FPS,"
            << " num frames in chunk: " << num_frames_since_last_check_;
 
   num_frames_since_last_check_ = 0;
   encoded_stream_size_since_last_check_ = 0;
 
   if (force_bitrate_) {
-    EXPECT_NEAR(bitrate,
-                current_requested_bitrate_,
+    EXPECT_NEAR(bitrate, current_requested_bitrate_,
                 kBitrateTolerance * current_requested_bitrate_);
   }
 
   // All requested keyframes should've been provided. Allow the last requested
   // frame to remain undelivered if we haven't reached the maximum frame number
   // by which it should have arrived.
-  if (num_encoded_frames_ < next_keyframe_at_  + kMaxKeyframeDelay)
+  if (num_encoded_frames_ < next_keyframe_at_ + kMaxKeyframeDelay)
     EXPECT_LE(num_keyframes_requested_, 1UL);
   else
     EXPECT_EQ(num_keyframes_requested_, 0UL);
 }
 
 void VEAClient::WriteIvfFileHeader() {
   media::IvfFileHeader header = {};
 
   memcpy(header.signature, media::kIvfHeaderSignature,
          sizeof(header.signature));
@@ skipping 45 matching lines @@
   size_t num_concurrent_encoders = base::get<0>(GetParam());
   const bool save_to_file = base::get<1>(GetParam());
   const unsigned int keyframe_period = base::get<2>(GetParam());
   const bool force_bitrate = base::get<3>(GetParam());
   const bool test_perf = base::get<4>(GetParam());
   const bool mid_stream_bitrate_switch = base::get<5>(GetParam());
   const bool mid_stream_framerate_switch = base::get<6>(GetParam());
   const bool verify_output =
       base::get<7>(GetParam()) || g_env->verify_all_output();
 
-  ScopedVector<ClientStateNotification<ClientState> > notes;
+  ScopedVector<ClientStateNotification<ClientState>> notes;
   ScopedVector<VEAClient> clients;
   base::Thread encoder_thread("EncoderThread");
   ASSERT_TRUE(encoder_thread.Start());
 
   if (g_env->test_streams_.size() > 1)
     num_concurrent_encoders = g_env->test_streams_.size();
 
   // Create all encoders.
   for (size_t i = 0; i < num_concurrent_encoders; i++) {
     size_t test_stream_index = i % g_env->test_streams_.size();
     // Disregard save_to_file if we didn't get an output filename.
     bool encoder_save_to_file =
         (save_to_file &&
          !g_env->test_streams_[test_stream_index]->out_filename.empty());
 
     notes.push_back(new ClientStateNotification<ClientState>());
     clients.push_back(new VEAClient(
         g_env->test_streams_[test_stream_index], notes.back(),
         encoder_save_to_file, keyframe_period, force_bitrate, test_perf,
         mid_stream_bitrate_switch, mid_stream_framerate_switch, verify_output));
 
     encoder_thread.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&VEAClient::CreateEncoder,
-                   base::Unretained(clients.back())));
+        FROM_HERE, base::Bind(&VEAClient::CreateEncoder,
+                              base::Unretained(clients.back())));
   }
 
   // All encoders must pass through states in this order.
   enum ClientState state_transitions[] = {
       CS_ENCODER_SET, CS_INITIALIZED, CS_ENCODING, CS_FINISHED, CS_VALIDATED};
 
   // Wait for all encoders to go through all states and finish.
   // Do this by waiting for all encoders to advance to state n before checking
   // state n+1, to verify that they are able to operate concurrently.
   // It also simulates the real-world usage better, as the main thread, on which
@@ skipping 82 matching lines @@
         base::MakeTuple(3, false, 0, false, false, false, false, false)));
 #endif
 
 // TODO(posciak): more tests:
 // - async FeedEncoderWithOutput
 // - out-of-order return of outputs to encoder
 // - multiple encoders + decoders
 // - mid-stream encoder_->Destroy()
 
 }  // namespace
-}  // namespace content
+}  // namespace media
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
   base::CommandLine::Init(argc, argv);
 
   base::ShadowingAtExitManager at_exit_manager;
   base::MessageLoop main_loop;
 
   std::unique_ptr<base::FilePath::StringType> test_stream_data(
       new base::FilePath::StringType(
-          media::GetTestDataFilePath(content::g_default_in_filename).value() +
-          content::g_default_in_parameters));
+          media::GetTestDataFilePath(media::g_default_in_filename).value() +
+          media::g_default_in_parameters));
 
   // 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);
 
   bool run_at_fps = false;
   bool needs_encode_latency = false;
   bool verify_all_output = false;
   base::FilePath log_path;
 
   base::CommandLine::SwitchMap switches = cmd_line->GetSwitches();
   for (base::CommandLine::SwitchMap::const_iterator it = switches.begin();
-       it != switches.end();
-       ++it) {
+       it != switches.end(); ++it) {
     if (it->first == "test_stream_data") {
       test_stream_data->assign(it->second.c_str());
       continue;
     }
     // Output machine-readable logs with fixed formats to a file.
     if (it->first == "output_log") {
       log_path = base::FilePath(
           base::FilePath::StringType(it->second.begin(), it->second.end()));
       continue;
     }
     if (it->first == "num_frames_to_encode") {
       std::string input(it->second.begin(), it->second.end());
-      LOG_ASSERT(base::StringToInt(input, &content::g_num_frames_to_encode));
+      LOG_ASSERT(base::StringToInt(input, &media::g_num_frames_to_encode));
       continue;
     }
     if (it->first == "measure_latency") {
       needs_encode_latency = true;
       continue;
     }
     if (it->first == "fake_encoder") {
-      content::g_fake_encoder = true;
+      media::g_fake_encoder = true;
       continue;
     }
     if (it->first == "run_at_fps") {
       run_at_fps = true;
       continue;
     }
     if (it->first == "verify_all_output") {
       verify_all_output = true;
       continue;
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     if (it->first == "ozone-platform" || it->first == "ozone-use-surfaceless")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   if (needs_encode_latency && !run_at_fps) {
     // Encode latency can only be measured with --run_at_fps. Otherwise, we get
     // skewed results since it may queue too many frames at once with the same
     // encode start time.
     LOG(FATAL) << "--measure_latency requires --run_at_fps enabled to work.";
   }
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  content::VaapiWrapper::PreSandboxInitialization();
+  media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
-  content::g_env =
-      reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
+  media::g_env =
+      reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
-              new content::VideoEncodeAcceleratorTestEnvironment(
+              new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }