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

media/gpu/dxva_picture_buffer_win.cc

 // Copyright 2016 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 "media/gpu/dxva_picture_buffer_win.h"
 
 #include "media/gpu/dxva_video_decode_accelerator_win.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
@@ skipping 18 matching lines @@
 
 enum {
   // The keyed mutex should always be released before the other thread
   // attempts to acquire it, so AcquireSync should always return immediately.
   kAcquireSyncWaitMs = 0,
 };
 
 // static
 linked_ptr<DXVAPictureBuffer> DXVAPictureBuffer::Create(
     const DXVAVideoDecodeAccelerator& decoder,
-    const media::PictureBuffer& buffer,
+    const PictureBuffer& buffer,
     EGLConfig egl_config) {
   if (decoder.share_nv12_textures_) {
     linked_ptr<EGLStreamPictureBuffer> picture_buffer(
         new EGLStreamPictureBuffer(buffer));
     if (!picture_buffer->Initialize())
       return linked_ptr<DXVAPictureBuffer>(nullptr);
 
     return picture_buffer;
   }
   linked_ptr<PbufferPictureBuffer> picture_buffer(
@@ skipping 27 matching lines @@
 gl::GLFence* DXVAPictureBuffer::reuse_fence() {
   return nullptr;
 }
 
 bool DXVAPictureBuffer::CopySurfaceComplete(IDirect3DSurface9* src_surface,
                                             IDirect3DSurface9* dest_surface) {
   NOTREACHED();
   return false;
 }
 
-DXVAPictureBuffer::DXVAPictureBuffer(const media::PictureBuffer& buffer)
+DXVAPictureBuffer::DXVAPictureBuffer(const PictureBuffer& buffer)
     : available_(true), picture_buffer_(buffer) {}
 
 bool DXVAPictureBuffer::BindSampleToTexture(
     base::win::ScopedComPtr<IMFSample> sample) {
   NOTREACHED();
   return false;
 }
 
 bool PbufferPictureBuffer::Initialize(const DXVAVideoDecodeAccelerator& decoder,
                                       EGLConfig egl_config) {
@@ skipping 179 matching lines @@
   }
 
   EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
   eglBindTexImage(egl_display, decoding_surface_, EGL_BACK_BUFFER);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glBindTexture(GL_TEXTURE_2D, current_texture);
   return true;
 }
 
-PbufferPictureBuffer::PbufferPictureBuffer(const media::PictureBuffer& buffer)
+PbufferPictureBuffer::PbufferPictureBuffer(const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer),
       waiting_to_reuse_(false),
       decoding_surface_(NULL),
       texture_share_handle_(nullptr),
       keyed_mutex_value_(0),
       use_rgb_(true) {}
 
 PbufferPictureBuffer::~PbufferPictureBuffer() {
   if (decoding_surface_) {
     EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
@@ skipping 15 matching lines @@
   decoder_dx11_texture_.Release();
   waiting_to_reuse_ = false;
   set_available(true);
   if (egl_keyed_mutex_) {
     HRESULT hr = egl_keyed_mutex_->ReleaseSync(++keyed_mutex_value_);
     RETURN_ON_FAILURE(hr == S_OK, "Could not release sync mutex", false);
   }
   return true;
 }
 
-EGLStreamPictureBuffer::EGLStreamPictureBuffer(
-    const media::PictureBuffer& buffer)
+EGLStreamPictureBuffer::EGLStreamPictureBuffer(const PictureBuffer& buffer)
     : DXVAPictureBuffer(buffer), stream_(nullptr) {}
 
 EGLStreamPictureBuffer::~EGLStreamPictureBuffer() {
   if (stream_) {
     EGLDisplay egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
     eglDestroyStreamKHR(egl_display, stream_);
     stream_ = nullptr;
   }
 }
 
@@ skipping 83 matching lines @@
   EGLBoolean result = eglStreamPostD3DTextureNV12ANGLE(
       egl_display, stream_, static_cast<void*>(dx11_decoding_texture_.get()),
       frame_attributes);
   RETURN_ON_FAILURE(result, "Could not post texture", false);
   result = eglStreamConsumerAcquireKHR(egl_display, stream_);
   RETURN_ON_FAILURE(result, "Could not post acquire stream", false);
   return true;
 }
 
 }  // namespace media