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

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>
@@ skipping 24 matching lines @@
 #if defined(USE_V4L2_CODEC)
 #include "media/gpu/v4l2_device.h"
 #include "media/gpu/v4l2_jpeg_decode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_jpeg_decode_accelerator.h"
 #include "media/gpu/vaapi_wrapper.h"
 #endif
 #endif
 
-using media::JpegDecodeAccelerator;
-
 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.
 // Absolute difference is to calculate the difference between each pixel in two
 // images. This is used for measuring of the similarity of two images.
 const double kDecodeSimilarityThreshold = 1.0;
 
 // Environment to create test data for all test cases.
 class JpegDecodeAcceleratorTestEnvironment;
 JpegDecodeAcceleratorTestEnvironment* g_env;
 
 struct TestImageFile {
   explicit TestImageFile(const base::FilePath::StringType& filename)
       : filename(filename) {}
 
   base::FilePath::StringType filename;
 
   // The input content of |filename|.
   std::string data_str;
 
-  media::JpegParseResult parse_result;
+  JpegParseResult parse_result;
   gfx::Size visible_size;
   size_t output_size;
 };
 
 enum ClientState {
   CS_CREATED,
   CS_INITIALIZED,
   CS_DECODE_PASS,
   CS_ERROR,
 };
@@ skipping 157 matching lines @@
 }
 
 void JpegClient::StartDecode(int32_t bitstream_buffer_id) {
   DCHECK_LT(static_cast<size_t>(bitstream_buffer_id), test_image_files_.size());
   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());
+  BitstreamBuffer bitstream_buffer(bitstream_buffer_id, dup_handle,
+                                   image_file->data_str.size());
+  scoped_refptr<VideoFrame> out_frame_ = VideoFrame::WrapExternalSharedMemory(
+      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;
+  VideoPixelFormat format = 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();
-  uint8_t* vplane =
-      uplane +
-      media::VideoFrame::PlaneSize(format, media::VideoFrame::kUPlane,
-                                   image_file->visible_size)
-          .GetArea();
+  uint8_t* uplane = yplane +
+                    VideoFrame::PlaneSize(format, VideoFrame::kYPlane,
+                                          image_file->visible_size)
+                        .GetArea();
+  uint8_t* vplane = uplane +
+                    VideoFrame::PlaneSize(format, VideoFrame::kUPlane,
+                                          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,
@@ skipping 68 matching lines @@
   image_data_640x368_black_.reset(
       new TestImageFile(test_640x368_jpeg_file_.value()));
   ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(test_640x368_jpeg_file_,
                                             image_data_640x368_black_.get()));
 
   image_data_640x360_black_.reset(
       new TestImageFile(test_640x360_jpeg_file_.value()));
   ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(test_640x360_jpeg_file_,
                                             image_data_640x360_black_.get()));
 
-  base::FilePath default_jpeg_file =
-      media::GetTestDataFilePath(kDefaultJpegFilename);
+  base::FilePath default_jpeg_file = GetTestDataFilePath(kDefaultJpegFilename);
   image_data_1280x720_default_.reset(new TestImageFile(kDefaultJpegFilename));
   ASSERT_NO_FATAL_FAILURE(
       ReadTestJpegImage(default_jpeg_file, image_data_1280x720_default_.get()));
 
   image_data_invalid_.reset(new TestImageFile("failure.jpg"));
   image_data_invalid_->data_str.resize(100, 0);
   image_data_invalid_->visible_size.SetSize(1280, 720);
-  image_data_invalid_->output_size = media::VideoFrame::AllocationSize(
-      media::PIXEL_FORMAT_I420, image_data_invalid_->visible_size);
+  image_data_invalid_->output_size = VideoFrame::AllocationSize(
+      PIXEL_FORMAT_I420, image_data_invalid_->visible_size);
 
   // |user_jpeg_filenames_| may include many files and use ';' as delimiter.
   std::vector<base::FilePath::StringType> filenames = base::SplitString(
       user_jpeg_filenames_, base::FilePath::StringType(1, ';'),
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (const auto& filename : filenames) {
-    base::FilePath input_file = media::GetTestDataFilePath(filename);
+    base::FilePath input_file = GetTestDataFilePath(filename);
     TestImageFile* image_data = new TestImageFile(filename);
     ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(input_file, image_data));
     image_data_user_.push_back(image_data);
   }
 }
 
 void JpegDecodeAcceleratorTestEnvironment::TearDown() {
   base::DeleteFile(test_1280x720_jpeg_file_, false);
   base::DeleteFile(test_640x368_jpeg_file_, false);
   base::DeleteFile(test_640x360_jpeg_file_, false);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(base::AppendToFile(
       *filename, reinterpret_cast<char*>(&encoded[0]), encoded.size()));
   return true;
 }
 
 void JpegDecodeAcceleratorTestEnvironment::ReadTestJpegImage(
     base::FilePath& input_file,
     TestImageFile* image_data) {
   ASSERT_TRUE(base::ReadFileToString(input_file, &image_data->data_str));
 
-  ASSERT_TRUE(media::ParseJpegPicture(
+  ASSERT_TRUE(ParseJpegPicture(
       reinterpret_cast<const uint8_t*>(image_data->data_str.data()),
       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);
+  image_data->output_size =
+      VideoFrame::AllocationSize(PIXEL_FORMAT_I420, image_data->visible_size);
 }
 
 class JpegDecodeAcceleratorTest : public ::testing::Test {
  protected:
   JpegDecodeAcceleratorTest() {}
 
   void TestDecode(size_t num_concurrent_decoders);
 
   // The elements of |test_image_files_| are owned by
   // JpegDecodeAcceleratorTestEnvironment.
@@ skipping 132 matching lines @@
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env = reinterpret_cast<media::JpegDecodeAcceleratorTestEnvironment*>(
       testing::AddGlobalTestEnvironment(
           new media::JpegDecodeAcceleratorTestEnvironment(jpeg_filenames)));
 
   return RUN_ALL_TESTS();
 }