media: Drop "media::" in media/gpu

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 45 matching lines @@
 #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 "media/gpu/vt_video_encode_accelerator_mac.h"
 #else
 #error The VideoEncodeAcceleratorUnittest is not supported on this platform.
 #endif
 
-using media::VideoEncodeAccelerator;
-
 namespace media {
 namespace {
 
-const media::VideoPixelFormat kInputFormat = media::PIXEL_FORMAT_I420;
+const VideoPixelFormat kInputFormat = 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.
 const unsigned int kNumOutputBuffers = 4;
 const unsigned int kNumExtraInputFrames = 4;
 // Maximum delay between requesting a keyframe and receiving one, in frames.
@@ skipping 24 matching lines @@
 
 // The syntax of multiple test streams is:
 //  test-stream1;test-stream2;test-stream3
 // The syntax of each test stream is:
 // "in_filename:width:height:profile:out_filename:requested_bitrate
 //  :requested_framerate:requested_subsequent_bitrate
 //  :requested_subsequent_framerate"
 // - |in_filename| must be an I420 (YUV planar) raw stream
 //   (see http://www.fourcc.org/yuv.php#IYUV).
 // - |width| and |height| are in pixels.
-// - |profile| to encode into (values of media::VideoCodecProfile).
+// - |profile| to encode into (values of VideoCodecProfile).
 // - |out_filename| filename to save the encoded stream to (optional). The
 //   format for H264 is Annex-B byte stream. The format for VP8 is IVF. Output
 //   stream is saved for the simple encode test only. H264 raw stream and IVF
 //   can be used as input of VDA unittest. H264 raw stream can be played by
 //   "mplayer -fps 25 out.h264" and IVF can be played by mplayer directly.
 //   Helpful description: http://wiki.multimedia.cx/index.php?title=IVF
 // Further parameters are optional (need to provide preceding positional
 // parameters if a specific subsequent parameter is required):
 // - |requested_bitrate| requested bitrate in bits per second.
 // - |requested_framerate| requested initial framerate.
@@ skipping 43 matching lines @@
   // makes sure starting address of YUV planes are 64 bytes-aligned.
   std::vector<char> aligned_in_file_data;
 
   // Byte size of a frame of |aligned_in_file_data|.
   size_t aligned_buffer_size;
 
   // Byte size for each aligned plane of a frame.
   std::vector<size_t> aligned_plane_size;
 
   std::string out_filename;
-  media::VideoCodecProfile requested_profile;
+  VideoCodecProfile requested_profile;
   unsigned int requested_bitrate;
   unsigned int requested_framerate;
   unsigned int requested_subsequent_bitrate;
   unsigned int requested_subsequent_framerate;
 };
 
 inline static size_t Align64Bytes(size_t value) {
   return (value + 63) & ~63;
 }
 
 // Return the |percentile| from a sorted vector.
 static base::TimeDelta Percentile(
     const std::vector<base::TimeDelta>& sorted_values,
     unsigned int percentile) {
   size_t size = sorted_values.size();
   LOG_ASSERT(size > 0UL);
   LOG_ASSERT(percentile <= 100UL);
   // Use Nearest Rank method in http://en.wikipedia.org/wiki/Percentile.
   int index =
       std::max(static_cast<int>(ceil(0.01f * percentile * size)) - 1, 0);
   return sorted_values[index];
 }
 
-static bool IsH264(media::VideoCodecProfile profile) {
-  return profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX;
+static bool IsH264(VideoCodecProfile profile) {
+  return profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX;
 }
 
-static bool IsVP8(media::VideoCodecProfile profile) {
-  return profile >= media::VP8PROFILE_MIN && profile <= media::VP8PROFILE_MAX;
+static bool IsVP8(VideoCodecProfile profile) {
+  return profile >= VP8PROFILE_MIN && profile <= VP8PROFILE_MAX;
 }
 
 // ARM performs CPU cache management with CPU cache line granularity. We thus
 // need to ensure our buffers are CPU cache line-aligned (64 byte-aligned).
 // Otherwise newer kernels will refuse to accept them, and on older kernels
 // we'll be treating ourselves to random corruption.
 // Since we are just mapping and passing chunks of the input file directly to
 // the VEA as input frames to avoid copying large chunks of raw data on each
 // frame and thus affecting performance measurements, we have to prepare a
 // temporary file with all planes aligned to 64-byte boundaries beforehand.
 static void CreateAlignedInputStreamFile(const gfx::Size& coded_size,
                                          TestStream* test_stream) {
   // Test case may have many encoders and memory should be prepared once.
   if (test_stream->coded_size == coded_size &&
       !test_stream->aligned_in_file_data.empty())
     return;
 
   // All encoders in multiple encoder test reuse the same test_stream, make
   // sure they requested the same coded_size
   ASSERT_TRUE(test_stream->aligned_in_file_data.empty() ||
               coded_size == test_stream->coded_size);
   test_stream->coded_size = coded_size;
 
-  size_t num_planes = media::VideoFrame::NumPlanes(kInputFormat);
+  size_t num_planes = VideoFrame::NumPlanes(kInputFormat);
   std::vector<size_t> padding_sizes(num_planes);
   std::vector<size_t> coded_bpl(num_planes);
   std::vector<size_t> visible_bpl(num_planes);
   std::vector<size_t> visible_plane_rows(num_planes);
 
   // Calculate padding in bytes to be added after each plane required to keep
   // starting addresses of all planes at a 64 byte boudnary. This padding will
   // be added after each plane when copying to the temporary file.
   // At the same time we also need to take into account coded_size requested by
   // the VEA; each row of visible_bpl bytes in the original file needs to be
   // copied into a row of coded_bpl bytes in the aligned file.
   for (size_t i = 0; i < num_planes; i++) {
     const size_t size =
-        media::VideoFrame::PlaneSize(kInputFormat, i, coded_size).GetArea();
+        VideoFrame::PlaneSize(kInputFormat, i, coded_size).GetArea();
     test_stream->aligned_plane_size.push_back(Align64Bytes(size));
     test_stream->aligned_buffer_size += test_stream->aligned_plane_size.back();
 
-    coded_bpl[i] =
-        media::VideoFrame::RowBytes(i, kInputFormat, coded_size.width());
-    visible_bpl[i] = media::VideoFrame::RowBytes(
-        i, kInputFormat, test_stream->visible_size.width());
-    visible_plane_rows[i] = media::VideoFrame::Rows(
-        i, kInputFormat, test_stream->visible_size.height());
+    coded_bpl[i] = VideoFrame::RowBytes(i, kInputFormat, coded_size.width());
+    visible_bpl[i] = VideoFrame::RowBytes(i, kInputFormat,
+                                          test_stream->visible_size.width());
+    visible_plane_rows[i] =
+        VideoFrame::Rows(i, kInputFormat, test_stream->visible_size.height());
     const size_t padding_rows =
-        media::VideoFrame::Rows(i, kInputFormat, coded_size.height()) -
+        VideoFrame::Rows(i, kInputFormat, coded_size.height()) -
         visible_plane_rows[i];
     padding_sizes[i] = padding_rows * coded_bpl[i] + Align64Bytes(size) - size;
   }
 
   base::FilePath src_file(test_stream->in_filename);
   int64_t src_file_size = 0;
   LOG_ASSERT(base::GetFileSize(src_file, &src_file_size));
 
-  size_t visible_buffer_size = media::VideoFrame::AllocationSize(
-      kInputFormat, test_stream->visible_size);
+  size_t visible_buffer_size =
+      VideoFrame::AllocationSize(kInputFormat, test_stream->visible_size);
   LOG_ASSERT(src_file_size % visible_buffer_size == 0U)
       << "Stream byte size is not a product of calculated frame byte size";
 
   test_stream->num_frames = src_file_size / visible_buffer_size;
 
   LOG_ASSERT(test_stream->aligned_buffer_size > 0UL);
   test_stream->aligned_in_file_data.resize(test_stream->aligned_buffer_size *
                                            test_stream->num_frames);
 
   base::File src(src_file, base::File::FLAG_OPEN | base::File::FLAG_READ);
@@ skipping 51 matching lines @@
     int width, height;
     bool result = base::StringToInt(fields[1], &width);
     LOG_ASSERT(result);
     result = base::StringToInt(fields[2], &height);
     LOG_ASSERT(result);
     test_stream->visible_size = gfx::Size(width, height);
     LOG_ASSERT(!test_stream->visible_size.IsEmpty());
     int profile;
     result = base::StringToInt(fields[3], &profile);
     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);
+    LOG_ASSERT(profile > VIDEO_CODEC_PROFILE_UNKNOWN);
+    LOG_ASSERT(profile <= VIDEO_CODEC_PROFILE_MAX);
+    test_stream->requested_profile = static_cast<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));
 
     if (fields.size() >= 7 && !fields[6].empty())
       LOG_ASSERT(
@@ skipping 102 matching lines @@
  public:
   // To be called when a complete frame is found while processing a stream
   // buffer, passing true if the frame is a keyframe. Returns false if we
   // are not interested in more frames and further processing should be aborted.
   typedef base::Callback<bool(bool)> FrameFoundCallback;
 
   virtual ~StreamValidator() {}
 
   // Provide a StreamValidator instance for the given |profile|.
   static std::unique_ptr<StreamValidator> Create(
-      media::VideoCodecProfile profile,
+      VideoCodecProfile profile,
       const FrameFoundCallback& frame_cb);
 
   // Process and verify contents of a bitstream buffer.
   virtual void ProcessStreamBuffer(const uint8_t* stream, size_t size) = 0;
 
  protected:
   explicit StreamValidator(const FrameFoundCallback& frame_cb)
       : frame_cb_(frame_cb) {}
 
   FrameFoundCallback frame_cb_;
 };
 
 class H264Validator : public StreamValidator {
  public:
   explicit H264Validator(const FrameFoundCallback& frame_cb)
       : StreamValidator(frame_cb),
         seen_sps_(false),
         seen_pps_(false),
         seen_idr_(false) {}
 
   void ProcessStreamBuffer(const uint8_t* stream, size_t size) override;
 
  private:
   // Set to true when encoder provides us with the corresponding NALU type.
   bool seen_sps_;
   bool seen_pps_;
   bool seen_idr_;
 
-  media::H264Parser h264_parser_;
+  H264Parser h264_parser_;
 };
 
 void H264Validator::ProcessStreamBuffer(const uint8_t* stream, size_t size) {
   h264_parser_.SetStream(stream, size);
 
   while (1) {
-    media::H264NALU nalu;
-    media::H264Parser::Result result;
+    H264NALU nalu;
+    H264Parser::Result result;
 
     result = h264_parser_.AdvanceToNextNALU(&nalu);
-    if (result == media::H264Parser::kEOStream)
+    if (result == H264Parser::kEOStream)
       break;
 
-    ASSERT_EQ(media::H264Parser::kOk, result);
+    ASSERT_EQ(H264Parser::kOk, result);
 
     bool keyframe = false;
 
     switch (nalu.nal_unit_type) {
-      case media::H264NALU::kIDRSlice:
+      case H264NALU::kIDRSlice:
         ASSERT_TRUE(seen_sps_);
         ASSERT_TRUE(seen_pps_);
         seen_idr_ = true;
         keyframe = true;
       // fallthrough
-      case media::H264NALU::kNonIDRSlice: {
+      case H264NALU::kNonIDRSlice: {
         ASSERT_TRUE(seen_idr_);
         if (!frame_cb_.Run(keyframe))
           return;
         break;
       }
 
-      case media::H264NALU::kSPS: {
+      case H264NALU::kSPS: {
         int sps_id;
-        ASSERT_EQ(media::H264Parser::kOk, h264_parser_.ParseSPS(&sps_id));
+        ASSERT_EQ(H264Parser::kOk, h264_parser_.ParseSPS(&sps_id));
         seen_sps_ = true;
         break;
       }
 
-      case media::H264NALU::kPPS: {
+      case H264NALU::kPPS: {
         ASSERT_TRUE(seen_sps_);
         int pps_id;
-        ASSERT_EQ(media::H264Parser::kOk, h264_parser_.ParsePPS(&pps_id));
+        ASSERT_EQ(H264Parser::kOk, h264_parser_.ParsePPS(&pps_id));
         seen_pps_ = true;
         break;
       }
 
       default:
         break;
     }
   }
 }
 
@@ skipping 17 matching lines @@
   EXPECT_TRUE(seen_keyframe_);
 
   frame_cb_.Run(keyframe);
   // TODO(posciak): We could be getting more frames in the buffer, but there is
   // no simple way to detect this. We'd need to parse the frames and go through
   // partition numbers/sizes. For now assume one frame per buffer.
 }
 
 // static
 std::unique_ptr<StreamValidator> StreamValidator::Create(
-    media::VideoCodecProfile profile,
+    VideoCodecProfile profile,
     const FrameFoundCallback& frame_cb) {
   std::unique_ptr<StreamValidator> validator;
 
   if (IsH264(profile)) {
     validator.reset(new H264Validator(frame_cb));
   } else if (IsVP8(profile)) {
     validator.reset(new VP8Validator(frame_cb));
   } else {
     LOG(FATAL) << "Unsupported profile: " << profile;
   }
 
   return validator;
 }
 
 class VideoFrameQualityValidator {
  public:
-  VideoFrameQualityValidator(const media::VideoCodecProfile profile,
+  VideoFrameQualityValidator(const VideoCodecProfile profile,
                              const base::Closure& flush_complete_cb,
                              const base::Closure& decode_error_cb);
   void Initialize(const gfx::Size& coded_size, const gfx::Rect& visible_size);
   // Save original YUV frame to compare it with the decoded frame later.
-  void AddOriginalFrame(scoped_refptr<media::VideoFrame> frame);
-  void AddDecodeBuffer(const scoped_refptr<media::DecoderBuffer>& buffer);
+  void AddOriginalFrame(scoped_refptr<VideoFrame> frame);
+  void AddDecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer);
   // Flush the decoder.
   void Flush();
 
  private:
   void InitializeCB(bool success);
-  void DecodeDone(media::DecodeStatus status);
-  void FlushDone(media::DecodeStatus status);
-  void VerifyOutputFrame(const scoped_refptr<media::VideoFrame>& output_frame);
+  void DecodeDone(DecodeStatus status);
+  void FlushDone(DecodeStatus status);
+  void VerifyOutputFrame(const scoped_refptr<VideoFrame>& output_frame);
   void Decode();
 
   enum State { UNINITIALIZED, INITIALIZED, DECODING, ERROR };
 
-  const media::VideoCodecProfile profile_;
-  std::unique_ptr<media::FFmpegVideoDecoder> decoder_;
-  media::VideoDecoder::DecodeCB decode_cb_;
+  const VideoCodecProfile profile_;
+  std::unique_ptr<FFmpegVideoDecoder> decoder_;
+  VideoDecoder::DecodeCB decode_cb_;
   // Decode callback of an EOS buffer.
-  media::VideoDecoder::DecodeCB eos_decode_cb_;
+  VideoDecoder::DecodeCB eos_decode_cb_;
   // Callback of Flush(). Called after all frames are decoded.
   const base::Closure flush_complete_cb_;
   const base::Closure decode_error_cb_;
   State decoder_state_;
-  std::queue<scoped_refptr<media::VideoFrame>> original_frames_;
-  std::queue<scoped_refptr<media::DecoderBuffer>> decode_buffers_;
+  std::queue<scoped_refptr<VideoFrame>> original_frames_;
+  std::queue<scoped_refptr<DecoderBuffer>> decode_buffers_;
 };
 
 VideoFrameQualityValidator::VideoFrameQualityValidator(
-    const media::VideoCodecProfile profile,
+    const VideoCodecProfile profile,
     const base::Closure& flush_complete_cb,
     const base::Closure& decode_error_cb)
     : profile_(profile),
-      decoder_(new media::FFmpegVideoDecoder()),
+      decoder_(new FFmpegVideoDecoder()),
       decode_cb_(base::Bind(&VideoFrameQualityValidator::DecodeDone,
                             base::Unretained(this))),
       eos_decode_cb_(base::Bind(&VideoFrameQualityValidator::FlushDone,
                                 base::Unretained(this))),
       flush_complete_cb_(flush_complete_cb),
       decode_error_cb_(decode_error_cb),
       decoder_state_(UNINITIALIZED) {
   // Allow decoding of individual NALU. Entire frames are required by default.
   decoder_->set_decode_nalus(true);
 }
 
 void VideoFrameQualityValidator::Initialize(const gfx::Size& coded_size,
                                             const gfx::Rect& visible_size) {
-  media::FFmpegGlue::InitializeFFmpeg();
+  FFmpegGlue::InitializeFFmpeg();
 
   gfx::Size natural_size(visible_size.size());
   // The default output format of ffmpeg video decoder is YV12.
-  media::VideoDecoderConfig config;
+  VideoDecoderConfig config;
   if (IsVP8(profile_))
-    config.Initialize(media::kCodecVP8, media::VP8PROFILE_ANY, kInputFormat,
-                      media::COLOR_SPACE_UNSPECIFIED, coded_size, visible_size,
-                      natural_size, media::EmptyExtraData(),
-                      media::Unencrypted());
+    config.Initialize(kCodecVP8, VP8PROFILE_ANY, kInputFormat,
+                      COLOR_SPACE_UNSPECIFIED, coded_size, visible_size,
+                      natural_size, EmptyExtraData(), Unencrypted());
   else if (IsH264(profile_))
-    config.Initialize(media::kCodecH264, media::H264PROFILE_MAIN, kInputFormat,
-                      media::COLOR_SPACE_UNSPECIFIED, coded_size, visible_size,
-                      natural_size, media::EmptyExtraData(),
-                      media::Unencrypted());
+    config.Initialize(kCodecH264, H264PROFILE_MAIN, kInputFormat,
+                      COLOR_SPACE_UNSPECIFIED, coded_size, visible_size,
+                      natural_size, EmptyExtraData(), Unencrypted());
   else
     LOG_ASSERT(0) << "Invalid profile " << profile_;
 
   decoder_->Initialize(
       config, false, nullptr,
       base::Bind(&VideoFrameQualityValidator::InitializeCB,
                  base::Unretained(this)),
       base::Bind(&VideoFrameQualityValidator::VerifyOutputFrame,
                  base::Unretained(this)));
 }
 
 void VideoFrameQualityValidator::InitializeCB(bool success) {
   if (success) {
     decoder_state_ = INITIALIZED;
     Decode();
   } else {
     decoder_state_ = ERROR;
     if (IsH264(profile_))
       LOG(ERROR) << "Chromium does not support H264 decode. Try Chrome.";
     FAIL() << "Decoder initialization error";
     decode_error_cb_.Run();
   }
 }
 
 void VideoFrameQualityValidator::AddOriginalFrame(
-    scoped_refptr<media::VideoFrame> frame) {
+    scoped_refptr<VideoFrame> frame) {
   original_frames_.push(frame);
 }
 
-void VideoFrameQualityValidator::DecodeDone(media::DecodeStatus status) {
-  if (status == media::DecodeStatus::OK) {
+void VideoFrameQualityValidator::DecodeDone(DecodeStatus status) {
+  if (status == DecodeStatus::OK) {
     decoder_state_ = INITIALIZED;
     Decode();
   } else {
     decoder_state_ = ERROR;
     FAIL() << "Unexpected decode status = " << status << ". Stop decoding.";
     decode_error_cb_.Run();
   }
 }
 
-void VideoFrameQualityValidator::FlushDone(media::DecodeStatus status) {
+void VideoFrameQualityValidator::FlushDone(DecodeStatus status) {
   flush_complete_cb_.Run();
 }
 
 void VideoFrameQualityValidator::Flush() {
   if (decoder_state_ != ERROR) {
-    decode_buffers_.push(media::DecoderBuffer::CreateEOSBuffer());
+    decode_buffers_.push(DecoderBuffer::CreateEOSBuffer());
     Decode();
   }
 }
 
 void VideoFrameQualityValidator::AddDecodeBuffer(
-    const scoped_refptr<media::DecoderBuffer>& buffer) {
+    const scoped_refptr<DecoderBuffer>& buffer) {
   if (decoder_state_ != ERROR) {
     decode_buffers_.push(buffer);
     Decode();
   }
 }
 
 void VideoFrameQualityValidator::Decode() {
   if (decoder_state_ == INITIALIZED && !decode_buffers_.empty()) {
-    scoped_refptr<media::DecoderBuffer> next_buffer = decode_buffers_.front();
+    scoped_refptr<DecoderBuffer> next_buffer = decode_buffers_.front();
     decode_buffers_.pop();
     decoder_state_ = DECODING;
     if (next_buffer->end_of_stream())
       decoder_->Decode(next_buffer, eos_decode_cb_);
     else
       decoder_->Decode(next_buffer, decode_cb_);
   }
 }
 
 void VideoFrameQualityValidator::VerifyOutputFrame(
-    const scoped_refptr<media::VideoFrame>& output_frame) {
-  scoped_refptr<media::VideoFrame> original_frame = original_frames_.front();
+    const scoped_refptr<VideoFrame>& output_frame) {
+  scoped_refptr<VideoFrame> original_frame = original_frames_.front();
   original_frames_.pop();
   gfx::Size visible_size = original_frame->visible_rect().size();
 
-  int planes[] = {media::VideoFrame::kYPlane, media::VideoFrame::kUPlane,
-                  media::VideoFrame::kVPlane};
+  int planes[] = {VideoFrame::kYPlane, VideoFrame::kUPlane,
+                  VideoFrame::kVPlane};
   double difference = 0;
   for (int plane : planes) {
     uint8_t* original_plane = original_frame->data(plane);
     uint8_t* output_plane = output_frame->data(plane);
 
-    size_t rows =
-        media::VideoFrame::Rows(plane, kInputFormat, visible_size.height());
+    size_t rows = VideoFrame::Rows(plane, kInputFormat, visible_size.height());
     size_t columns =
-        media::VideoFrame::Columns(plane, kInputFormat, visible_size.width());
+        VideoFrame::Columns(plane, kInputFormat, visible_size.width());
     size_t stride = original_frame->stride(plane);
 
     for (size_t i = 0; i < rows; i++)
       for (size_t j = 0; j < columns; j++)
         difference += std::abs(original_plane[stride * i + j] -
                                output_plane[stride * i + j]);
   }
   // Divide the difference by the size of frame.
-  difference /= media::VideoFrame::AllocationSize(kInputFormat, visible_size);
+  difference /= VideoFrame::AllocationSize(kInputFormat, visible_size);
   EXPECT_TRUE(difference <= kDecodeSimilarityThreshold)
       << "differrence = " << difference << "  > decode similarity threshold";
 }
 
 class VEAClient : public VideoEncodeAccelerator::Client {
  public:
   VEAClient(TestStream* test_stream,
             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
@@ skipping 15 matching lines @@
                             bool key_frame,
                             base::TimeDelta timestamp) override;
   void NotifyError(VideoEncodeAccelerator::Error error) override;
 
  private:
   bool has_encoder() { return encoder_.get(); }
 
   // Return the number of encoded frames per second.
   double frames_per_second();
 
-  std::unique_ptr<media::VideoEncodeAccelerator> CreateFakeVEA();
-  std::unique_ptr<media::VideoEncodeAccelerator> CreateV4L2VEA();
-  std::unique_ptr<media::VideoEncodeAccelerator> CreateVaapiVEA();
-  std::unique_ptr<media::VideoEncodeAccelerator> CreateVTVEA();
+  std::unique_ptr<VideoEncodeAccelerator> CreateFakeVEA();
+  std::unique_ptr<VideoEncodeAccelerator> CreateV4L2VEA();
+  std::unique_ptr<VideoEncodeAccelerator> CreateVaapiVEA();
+  std::unique_ptr<VideoEncodeAccelerator> CreateVTVEA();
 
   void SetState(ClientState new_state);
 
   // Set current stream parameters to given |bitrate| at |framerate|.
   void SetStreamParameters(unsigned int bitrate, unsigned int framerate);
 
   // Called when encoder is done with a VideoFrame.
   void InputNoLongerNeededCallback(int32_t input_id);
 
   // Feed the encoder with one input frame.
@@ skipping 20 matching lines @@
   void LogPerf();
 
   // Write IVF file header to test_stream_->out_filename.
   void WriteIvfFileHeader();
 
   // Write an IVF frame header to test_stream_->out_filename.
   void WriteIvfFrameHeader(int frame_index, size_t frame_size);
 
   // Create and return a VideoFrame wrapping the data at |position| bytes in the
   // input stream.
-  scoped_refptr<media::VideoFrame> CreateFrame(off_t position);
+  scoped_refptr<VideoFrame> CreateFrame(off_t position);
 
   // Prepare and return a frame wrapping the data at |position| bytes in the
   // input stream, ready to be sent to encoder.
   // The input frame id is returned in |input_id|.
-  scoped_refptr<media::VideoFrame> PrepareInputFrame(off_t position,
-                                                     int32_t* input_id);
+  scoped_refptr<VideoFrame> PrepareInputFrame(off_t position,
+                                              int32_t* input_id);
 
   // Update the parameters according to |mid_stream_bitrate_switch| and
   // |mid_stream_framerate_switch|.
   void UpdateTestStreamData(bool mid_stream_bitrate_switch,
                             bool mid_stream_framerate_switch);
 
   // Callback function of the |input_timer_|.
   void OnInputTimer();
 
   // Called when the quality validator has decoded all the frames.
@@ skipping 167 matching lines @@
   // 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());
 }
 
-std::unique_ptr<media::VideoEncodeAccelerator> VEAClient::CreateFakeVEA() {
-  std::unique_ptr<media::VideoEncodeAccelerator> encoder;
+std::unique_ptr<VideoEncodeAccelerator> VEAClient::CreateFakeVEA() {
+  std::unique_ptr<VideoEncodeAccelerator> encoder;
   if (g_fake_encoder) {
-    encoder.reset(new media::FakeVideoEncodeAccelerator(
+    encoder.reset(new FakeVideoEncodeAccelerator(
         scoped_refptr<base::SingleThreadTaskRunner>(
             base::ThreadTaskRunnerHandle::Get())));
   }
   return encoder;
 }
 
-std::unique_ptr<media::VideoEncodeAccelerator> VEAClient::CreateV4L2VEA() {
-  std::unique_ptr<media::VideoEncodeAccelerator> encoder;
+std::unique_ptr<VideoEncodeAccelerator> VEAClient::CreateV4L2VEA() {
+  std::unique_ptr<VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && (defined(ARCH_CPU_ARMEL) || \
                              (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;
+std::unique_ptr<VideoEncodeAccelerator> VEAClient::CreateVaapiVEA() {
+  std::unique_ptr<VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   encoder.reset(new VaapiVideoEncodeAccelerator());
 #endif
   return encoder;
 }
 
-std::unique_ptr<media::VideoEncodeAccelerator> VEAClient::CreateVTVEA() {
-  std::unique_ptr<media::VideoEncodeAccelerator> encoder;
+std::unique_ptr<VideoEncodeAccelerator> VEAClient::CreateVTVEA() {
+  std::unique_ptr<VideoEncodeAccelerator> encoder;
 #if defined(OS_MACOSX)
   encoder.reset(new VTVideoEncodeAccelerator());
 #endif
   return encoder;
 }
 
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
 
-  std::unique_ptr<media::VideoEncodeAccelerator> encoders[] = {
+  std::unique_ptr<VideoEncodeAccelerator> encoders[] = {
       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);
@@ skipping 157 matching lines @@
 
   const uint8_t* stream_ptr = static_cast<const uint8_t*>(shm->memory());
   if (payload_size > 0) {
     if (stream_validator_) {
       stream_validator_->ProcessStreamBuffer(stream_ptr, payload_size);
     } else {
       HandleEncodedFrame(key_frame);
     }
 
     if (quality_validator_) {
-      scoped_refptr<media::DecoderBuffer> buffer(media::DecoderBuffer::CopyFrom(
+      scoped_refptr<DecoderBuffer> buffer(DecoderBuffer::CopyFrom(
           reinterpret_cast<const uint8_t*>(shm->memory()),
           static_cast<int>(payload_size)));
       quality_validator_->AddDecodeBuffer(buffer);
       // Insert EOS buffer to flush the decoder.
       if (num_encoded_frames_ == num_frames_to_encode_)
         quality_validator_->Flush();
     }
 
     if (save_to_file_) {
       if (IsVP8(test_stream_->requested_profile))
@@ skipping 36 matching lines @@
 }
 
 void VEAClient::InputNoLongerNeededCallback(int32_t input_id) {
   std::set<int32_t>::iterator it = inputs_at_client_.find(input_id);
   ASSERT_NE(it, inputs_at_client_.end());
   inputs_at_client_.erase(it);
   if (!g_env->run_at_fps())
     FeedEncoderWithOneInput();
 }
 
-scoped_refptr<media::VideoFrame> VEAClient::CreateFrame(off_t position) {
+scoped_refptr<VideoFrame> VEAClient::CreateFrame(off_t position) {
   uint8_t* frame_data_y =
       reinterpret_cast<uint8_t*>(&test_stream_->aligned_in_file_data[0]) +
       position;
   uint8_t* frame_data_u = frame_data_y + test_stream_->aligned_plane_size[0];
   uint8_t* frame_data_v = frame_data_u + test_stream_->aligned_plane_size[1];
   CHECK_GT(current_framerate_, 0U);
 
-  scoped_refptr<media::VideoFrame> video_frame =
-      media::VideoFrame::WrapExternalYuvData(
-          kInputFormat, input_coded_size_,
-          gfx::Rect(test_stream_->visible_size), test_stream_->visible_size,
-          input_coded_size_.width(), input_coded_size_.width() / 2,
-          input_coded_size_.width() / 2, frame_data_y, frame_data_u,
-          frame_data_v,
-          base::TimeDelta().FromMilliseconds(
-              next_input_id_ * base::Time::kMillisecondsPerSecond /
-              current_framerate_));
+  scoped_refptr<VideoFrame> video_frame = VideoFrame::WrapExternalYuvData(
+      kInputFormat, input_coded_size_, gfx::Rect(test_stream_->visible_size),
+      test_stream_->visible_size, input_coded_size_.width(),
+      input_coded_size_.width() / 2, input_coded_size_.width() / 2,
+      frame_data_y, frame_data_u, frame_data_v,
+      base::TimeDelta().FromMilliseconds(next_input_id_ *
+                                         base::Time::kMillisecondsPerSecond /
+                                         current_framerate_));
   EXPECT_NE(nullptr, video_frame.get());
   return video_frame;
 }
 
-scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(
-    off_t position,
-    int32_t* input_id) {
+scoped_refptr<VideoFrame> VEAClient::PrepareInputFrame(off_t position,
+                                                       int32_t* input_id) {
   CHECK_LE(position + test_stream_->aligned_buffer_size,
            test_stream_->aligned_in_file_data.size());
 
-  scoped_refptr<media::VideoFrame> frame = CreateFrame(position);
+  scoped_refptr<VideoFrame> frame = CreateFrame(position);
   EXPECT_TRUE(frame);
-  frame->AddDestructionObserver(media::BindToCurrentLoop(
-      base::Bind(&VEAClient::InputNoLongerNeededCallback,
-                 base::Unretained(this), next_input_id_)));
+  frame->AddDestructionObserver(
+      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 16 matching lines @@
     // This is to flush the encoder with additional frames from the beginning
     // of the stream, or if the stream is shorter that the number of frames
     // we require for bitrate tests.
     pos_in_input_stream_ = 0;
   }
 
   if (quality_validator_)
     quality_validator_->AddOriginalFrame(CreateFrame(pos_in_input_stream_));
 
   int32_t input_id;
-  scoped_refptr<media::VideoFrame> video_frame =
+  scoped_refptr<VideoFrame> video_frame =
       PrepareInputFrame(pos_in_input_stream_, &input_id);
   pos_in_input_stream_ += test_stream_->aligned_buffer_size;
 
   bool force_keyframe = false;
   if (keyframe_period_ && input_id % keyframe_period_ == 0) {
     force_keyframe = true;
     ++num_keyframes_requested_;
   }
 
   if (input_id == 0) {
@@ skipping 10 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_);
+  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_);
@@ skipping 98 matching lines @@
   // 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)
     EXPECT_LE(num_keyframes_requested_, 1UL);
   else
     EXPECT_EQ(num_keyframes_requested_, 0UL);
 }
 
 void VEAClient::WriteIvfFileHeader() {
-  media::IvfFileHeader header = {};
+  IvfFileHeader header = {};
 
-  memcpy(header.signature, media::kIvfHeaderSignature,
-         sizeof(header.signature));
+  memcpy(header.signature, kIvfHeaderSignature, sizeof(header.signature));
   header.version = 0;
   header.header_size = sizeof(header);
   header.fourcc = 0x30385056;  // VP80
   header.width =
       base::checked_cast<uint16_t>(test_stream_->visible_size.width());
   header.height =
       base::checked_cast<uint16_t>(test_stream_->visible_size.height());
   header.timebase_denum = requested_framerate_;
   header.timebase_num = 1;
   header.num_frames = num_frames_to_encode_;
   header.ByteSwap();
 
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
 void VEAClient::WriteIvfFrameHeader(int frame_index, size_t frame_size) {
-  media::IvfFrameHeader header = {};
+  IvfFrameHeader header = {};
 
   header.frame_size = frame_size;
   header.timestamp = frame_index;
   header.ByteSwap();
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
 // Test parameters:
@@ skipping 231 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }