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

media/gpu/v4l2_slice_video_decode_accelerator.h

 // 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.
 
 #ifndef MEDIA_GPU_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <linux/videodev2.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 16 matching lines @@
 #include "media/gpu/vp8_decoder.h"
 #include "media/video/video_decode_accelerator.h"
 
 namespace media {
 
 // An implementation of VideoDecodeAccelerator that utilizes the V4L2 slice
 // level codec API for decoding. The slice level API provides only a low-level
 // decoding functionality and requires userspace to provide support for parsing
 // the input stream and managing decoder state across frames.
 class MEDIA_GPU_EXPORT V4L2SliceVideoDecodeAccelerator
-    : public media::VideoDecodeAccelerator {
+    : public VideoDecodeAccelerator {
  public:
   class V4L2DecodeSurface;
 
   V4L2SliceVideoDecodeAccelerator(
       const scoped_refptr<V4L2Device>& device,
       EGLDisplay egl_display,
       const GetGLContextCallback& get_gl_context_cb,
       const MakeGLContextCurrentCallback& make_context_current_cb);
   ~V4L2SliceVideoDecodeAccelerator() override;
 
-  // media::VideoDecodeAccelerator implementation.
+  // VideoDecodeAccelerator implementation.
   bool Initialize(const Config& config, Client* client) override;
-  void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
-  void AssignPictureBuffers(
-      const std::vector<media::PictureBuffer>& buffers) override;
+  void Decode(const BitstreamBuffer& bitstream_buffer) override;
+  void AssignPictureBuffers(const std::vector<PictureBuffer>& buffers) override;
   void ImportBufferForPicture(
       int32_t picture_buffer_id,
       const gfx::GpuMemoryBufferHandle& gpu_memory_buffer_handle) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
   void Destroy() override;
   bool TryToSetupDecodeOnSeparateThread(
       const base::WeakPtr<Client>& decode_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner)
       override;
 
-  static media::VideoDecodeAccelerator::SupportedProfiles
-  GetSupportedProfiles();
+  static VideoDecodeAccelerator::SupportedProfiles GetSupportedProfiles();
 
  private:
   class V4L2H264Accelerator;
   class V4L2VP8Accelerator;
 
   // Record for input buffers.
   struct InputRecord {
     InputRecord();
     int32_t input_id;
     void* address;
@@ skipping 145 matching lines @@
 
   // Called after all events are processed successfully (i.e. all Finish*()
   // methods return true) to return to decoding state.
   bool FinishEventProcessing();
 
   // Process pending events, if any.
   void ProcessPendingEventsIfNeeded();
 
   // Allocate V4L2 buffers and assign them to |buffers| provided by the client
   // via AssignPictureBuffers() on decoder thread.
-  void AssignPictureBuffersTask(
-      const std::vector<media::PictureBuffer>& buffers);
+  void AssignPictureBuffersTask(const std::vector<PictureBuffer>& buffers);
 
   // Use buffer backed by dmabuf file descriptors in |passed_dmabuf_fds| for the
   // OutputRecord associated with |picture_buffer_id|, taking ownership of the
   // file descriptors.
   void ImportBufferForPictureTask(
       int32_t picture_buffer_id,
       // TODO(posciak): (crbug.com/561749) we should normally be able to pass
       // the vector by itself via std::move, but it's not possible to do this
       // if this method is used as a callback.
       std::unique_ptr<std::vector<base::ScopedFD>> passed_dmabuf_fds);
@@ skipping 56 matching lines @@
     // AssignPictureBuffers().
     kAwaitingPictureBuffers,
     // Error state, set when sending NotifyError to client.
     kError,
   };
 
   // Buffer id for flush buffer, queued by FlushTask().
   const int kFlushBufferId = -2;
 
   // Handler for Decode() on decoder_thread_.
-  void DecodeTask(const media::BitstreamBuffer& bitstream_buffer);
+  void DecodeTask(const BitstreamBuffer& bitstream_buffer);
 
   // Schedule a new DecodeBufferTask if we are decoding.
   void ScheduleDecodeBufferTaskIfNeeded();
 
   // Main decoder loop. Keep decoding the current buffer in decoder_, asking
   // for more stream via TrySetNewBistreamBuffer() if decoder_ requests so,
   // and handle other returns from it appropriately.
   void DecodeBufferTask();
 
   // Check decoder_input_queue_ for any available buffers to decode and
@@ skipping 68 matching lines @@
 
   // Output queue state.
   bool output_streamon_;
   // Number of output buffers enqueued to the device.
   int output_buffer_queued_count_;
   // Output buffers ready to use.
   std::list<int> free_output_buffers_;
   // Mapping of int index to an output buffer record.
   std::vector<OutputRecord> output_buffer_map_;
 
-  media::VideoCodecProfile video_profile_;
+  VideoCodecProfile video_profile_;
   uint32_t output_format_fourcc_;
   gfx::Size visible_size_;
   gfx::Size coded_size_;
 
   struct BitstreamBufferRef;
   // Input queue of stream buffers coming from the client.
   std::queue<linked_ptr<BitstreamBufferRef>> decoder_input_queue_;
   // BitstreamBuffer currently being processed.
   std::unique_ptr<BitstreamBufferRef> decoder_current_bitstream_buffer_;
 
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(V4L2SliceVideoDecodeAccelerator);
 };
 
 class V4L2H264Picture;
 class V4L2VP8Picture;
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_