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

media/gpu/vaapi_wrapper.h

 // 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.
 //
 // This file contains an implementation of VaapiWrapper, used by
 // VaapiVideoDecodeAccelerator and VaapiH264Decoder for decode,
 // and VaapiVideoEncodeAccelerator for encode, to interface
 // with libva (VA-API library for hardware video codec).
 
 #ifndef MEDIA_GPU_VAAPI_WRAPPER_H_
@@ skipping 59 matching lines @@
       CodecMode mode,
       VAProfile va_profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Create VaapiWrapper for VideoCodecProfile. It maps VideoCodecProfile
   // |profile| to VAProfile.
   // |report_error_to_uma_cb| will be called independently from reporting
   // errors to clients via method return values.
   static scoped_refptr<VaapiWrapper> CreateForVideoCodec(
       CodecMode mode,
-      media::VideoCodecProfile profile,
+      VideoCodecProfile profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Return the supported video encode profiles.
-  static media::VideoEncodeAccelerator::SupportedProfiles
-  GetSupportedEncodeProfiles();
+  static VideoEncodeAccelerator::SupportedProfiles GetSupportedEncodeProfiles();
 
   // Return the supported video decode profiles.
-  static media::VideoDecodeAccelerator::SupportedProfiles
-  GetSupportedDecodeProfiles();
+  static VideoDecodeAccelerator::SupportedProfiles GetSupportedDecodeProfiles();
 
   // Return true when JPEG decode is supported.
   static bool IsJpegDecodeSupported();
 
   // Create |num_surfaces| backing surfaces in driver for VASurfaces of
   // |va_format|, each of size |size|. Returns true when successful, with the
   // created IDs in |va_surfaces| to be managed and later wrapped in
   // VASurfaces.
   // The client must DestroySurfaces() each time before calling this method
   // again to free the allocated surfaces first, but is not required to do so
@@ skipping 82 matching lines @@
                   VAImageFormat* format,
                   const gfx::Size& size,
                   VAImage* image,
                   void** mem);
 
   // Release the VAImage (and the associated memory mapping) obtained from
   // GetVaImage() or GetDerivedVaImage().
   void ReturnVaImage(VAImage* image);
 
   // Upload contents of |frame| into |va_surface_id| for encode.
-  bool UploadVideoFrameToSurface(const scoped_refptr<media::VideoFrame>& frame,
+  bool UploadVideoFrameToSurface(const scoped_refptr<VideoFrame>& frame,
                                  VASurfaceID va_surface_id);
 
   // Create a buffer of |size| bytes to be used as encode output.
   bool CreateCodedBuffer(size_t size, VABufferID* buffer_id);
 
   // Download the contents of the buffer with given |buffer_id| into a buffer of
   // size |target_size|, pointed to by |target_ptr|. The number of bytes
   // downloaded will be returned in |coded_data_size|. |sync_surface_id| will
   // be used as a sync point, i.e. it will have to become idle before starting
   // the download. |sync_surface_id| should be the source surface passed
@@ skipping 134 matching lines @@
   std::vector<ProfileInfo> GetSupportedProfileInfosForCodecModeInternal(
       CodecMode mode);
 
   // Lazily initialize static data after sandbox is enabled.  Return false on
   // init failure.
   static bool PostSandboxInitialization();
 
   // Map VideoCodecProfile enum values to VaProfile values. This function
   // includes a workaround for crbug.com/345569. If va_profile is h264 baseline
   // and it is not supported, we try constrained baseline.
-  static VAProfile ProfileToVAProfile(media::VideoCodecProfile profile,
+  static VAProfile ProfileToVAProfile(VideoCodecProfile profile,
                                       CodecMode mode);
 
   // Pointer to VADisplayState's member |va_lock_|. Guaranteed to be valid for
   // the lifetime of VaapiWrapper.
   base::Lock* va_lock_;
 
   // Allocated ids for VASurfaces.
   std::vector<VASurfaceID> va_surface_ids_;
 
   // VA format of surfaces with va_surface_ids_.
@@ skipping 31 matching lines @@
   // Singleton variable to store supported profile information for encode and
   // decode.
   static base::LazyInstance<LazyProfileInfos> profile_infos_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiWrapper);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_VAAPI_WRAPPER_H_