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

media/gpu/vaapi_jpeg_decoder_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.
 
 #include <stdint.h>
 #include <string.h>
 
 #include <string>
 
 // This has to be included first.
@@ skipping 25 matching lines @@
 class VaapiJpegDecoderTest : public ::testing::Test {
  protected:
   VaapiJpegDecoderTest() {}
 
   void SetUp() override {
     base::Closure report_error_cb = base::Bind(&LogOnError);
     wrapper_ = VaapiWrapper::Create(VaapiWrapper::kDecode,
                                     VAProfileJPEGBaseline, report_error_cb);
     ASSERT_TRUE(wrapper_);
 
-    base::FilePath input_file = media::GetTestDataFilePath(kTestFilename);
+    base::FilePath input_file = GetTestDataFilePath(kTestFilename);
 
     ASSERT_TRUE(base::ReadFileToString(input_file, &jpeg_data_))
         << "failed to read input data from " << input_file.value();
   }
 
   void TearDown() override { wrapper_ = nullptr; }
 
-  bool VerifyDecode(const media::JpegParseResult& parse_result,
+  bool VerifyDecode(const JpegParseResult& parse_result,
                     const std::string& md5sum);
 
  protected:
   scoped_refptr<VaapiWrapper> wrapper_;
   std::string jpeg_data_;
 };
 
-bool VaapiJpegDecoderTest::VerifyDecode(
-    const media::JpegParseResult& parse_result,
-    const std::string& expected_md5sum) {
+bool VaapiJpegDecoderTest::VerifyDecode(const JpegParseResult& parse_result,
+                                        const std::string& expected_md5sum) {
   gfx::Size size(parse_result.frame_header.coded_width,
                  parse_result.frame_header.coded_height);
 
   std::vector<VASurfaceID> va_surfaces;
   if (!wrapper_->CreateSurfaces(VA_RT_FORMAT_YUV420, size, 1, &va_surfaces))
     return false;
 
   if (!VaapiJpegDecoder::Decode(wrapper_.get(), parse_result, va_surfaces[0])) {
     LOG(ERROR) << "Decode failed";
     return false;
   }
 
   VAImage image;
   VAImageFormat format;
   const uint32_t kI420Fourcc = VA_FOURCC('I', '4', '2', '0');
   memset(&image, 0, sizeof(image));
   memset(&format, 0, sizeof(format));
   format.fourcc = kI420Fourcc;
   format.byte_order = VA_LSB_FIRST;
   format.bits_per_pixel = 12;  // 12 for I420
 
   void* mem;
   if (!wrapper_->GetVaImage(va_surfaces[0], &format, size, &image, &mem)) {
     LOG(ERROR) << "Cannot get VAImage";
     return false;
   }
   EXPECT_EQ(kI420Fourcc, image.format.fourcc);
 
-  base::StringPiece result(
-      reinterpret_cast<const char*>(mem),
-      media::VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420, size));
+  base::StringPiece result(reinterpret_cast<const char*>(mem),
+                           VideoFrame::AllocationSize(PIXEL_FORMAT_I420, size));
   EXPECT_EQ(expected_md5sum, base::MD5String(result));
 
   wrapper_->ReturnVaImage(&image);
 
   return true;
 }
 
 TEST_F(VaapiJpegDecoderTest, DecodeSuccess) {
-  media::JpegParseResult parse_result;
-  ASSERT_TRUE(media::ParseJpegPicture(
-      reinterpret_cast<const uint8_t*>(jpeg_data_.data()), jpeg_data_.size(),
-      &parse_result));
+  JpegParseResult parse_result;
+  ASSERT_TRUE(
+      ParseJpegPicture(reinterpret_cast<const uint8_t*>(jpeg_data_.data()),
+                       jpeg_data_.size(), &parse_result));
 
   EXPECT_TRUE(VerifyDecode(parse_result, kExpectedMd5Sum));
 }
 
 TEST_F(VaapiJpegDecoderTest, DecodeFail) {
-  media::JpegParseResult parse_result;
-  ASSERT_TRUE(media::ParseJpegPicture(
-      reinterpret_cast<const uint8_t*>(jpeg_data_.data()), jpeg_data_.size(),
-      &parse_result));
+  JpegParseResult parse_result;
+  ASSERT_TRUE(
+      ParseJpegPicture(reinterpret_cast<const uint8_t*>(jpeg_data_.data()),
+                       jpeg_data_.size(), &parse_result));
 
   // Not supported by VAAPI.
   parse_result.frame_header.num_components = 1;
   parse_result.scan.num_components = 1;
 
   gfx::Size size(parse_result.frame_header.coded_width,
                  parse_result.frame_header.coded_height);
 
   std::vector<VASurfaceID> va_surfaces;
   ASSERT_TRUE(
       wrapper_->CreateSurfaces(VA_RT_FORMAT_YUV420, size, 1, &va_surfaces));
 
   EXPECT_FALSE(
       VaapiJpegDecoder::Decode(wrapper_.get(), parse_result, va_surfaces[0]));
 }
 
 }  // namespace
 }  // namespace media
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   base::AtExitManager exit_manager;
   media::VaapiWrapper::PreSandboxInitialization();
   return RUN_ALL_TESTS();
 }