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

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.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 "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 54 matching lines @@
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 namespace media {
 
-class GpuJpegDecodeAccelerator::Client
-    : public media::JpegDecodeAccelerator::Client,
-      public base::NonThreadSafe {
+class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client,
+                                         public base::NonThreadSafe {
  public:
-  Client(media::GpuJpegDecodeAccelerator* owner, int32_t route_id)
+  Client(GpuJpegDecodeAccelerator* owner, int32_t route_id)
       : owner_(owner->AsWeakPtr()), route_id_(route_id) {}
 
   ~Client() override { DCHECK(CalledOnValidThread()); }
 
-  // media::JpegDecodeAccelerator::Client implementation.
+  // JpegDecodeAccelerator::Client implementation.
   void VideoFrameReady(int32_t bitstream_buffer_id) override {
     DCHECK(CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id,
-                                 media::JpegDecodeAccelerator::NO_ERRORS);
+                                 JpegDecodeAccelerator::NO_ERRORS);
   }
 
   void NotifyError(int32_t bitstream_buffer_id,
-                   media::JpegDecodeAccelerator::Error error) override {
+                   JpegDecodeAccelerator::Error error) override {
     DCHECK(CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, error);
   }
 
-  void Decode(const media::BitstreamBuffer& bitstream_buffer,
-              const scoped_refptr<media::VideoFrame>& video_frame) {
+  void Decode(const BitstreamBuffer& bitstream_buffer,
+              const scoped_refptr<VideoFrame>& video_frame) {
     DCHECK(CalledOnValidThread());
     DCHECK(accelerator_);
     accelerator_->Decode(bitstream_buffer, video_frame);
   }
 
-  void set_accelerator(
-      std::unique_ptr<media::JpegDecodeAccelerator> accelerator) {
+  void set_accelerator(std::unique_ptr<JpegDecodeAccelerator> accelerator) {
     DCHECK(CalledOnValidThread());
     accelerator_ = std::move(accelerator);
   }
 
  private:
-  base::WeakPtr<media::GpuJpegDecodeAccelerator> owner_;
+  base::WeakPtr<GpuJpegDecodeAccelerator> owner_;
   int32_t route_id_;
-  std::unique_ptr<media::JpegDecodeAccelerator> accelerator_;
+  std::unique_ptr<JpegDecodeAccelerator> accelerator_;
 };
 
 // Create, destroy, and RemoveClient run on child thread. All other methods run
 // on IO thread.
 class GpuJpegDecodeAccelerator::MessageFilter : public IPC::MessageFilter {
  public:
   explicit MessageFilter(GpuJpegDecodeAccelerator* owner)
       : owner_(owner->AsWeakPtr()),
         child_task_runner_(owner_->child_task_runner_),
         io_task_runner_(owner_->io_task_runner_) {}
@@ skipping 52 matching lines @@
 
   void DestroyClient(Client* client) {
     DCHECK(child_task_runner_->BelongsToCurrentThread());
     delete client;
     if (owner_)
       owner_->ClientRemoved();
   }
 
   void NotifyDecodeStatusOnIOThread(int32_t route_id,
                                     int32_t buffer_id,
-                                    media::JpegDecodeAccelerator::Error error) {
+                                    JpegDecodeAccelerator::Error error) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     SendOnIOThread(new AcceleratedJpegDecoderHostMsg_DecodeAck(
         route_id, buffer_id, error));
   }
 
   void OnDecodeOnIOThread(
       const int32_t* route_id,
       const AcceleratedJpegDecoderMsg_Decode_Params& params) {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     DCHECK(route_id);
     TRACE_EVENT0("jpeg", "GpuJpegDecodeAccelerator::MessageFilter::OnDecode");
 
     if (!VerifyDecodeParams(params)) {
-      NotifyDecodeStatusOnIOThread(
-          *route_id, params.input_buffer.id(),
-          media::JpegDecodeAccelerator::INVALID_ARGUMENT);
+      NotifyDecodeStatusOnIOThread(*route_id, params.input_buffer.id(),
+                                   JpegDecodeAccelerator::INVALID_ARGUMENT);
       if (base::SharedMemory::IsHandleValid(params.output_video_frame_handle))
         base::SharedMemory::CloseHandle(params.output_video_frame_handle);
       return;
     }
 
     // For handles in |params|, from now on, |params.output_video_frame_handle|
     // is taken cared by scoper. |params.input_buffer.handle()| need to be
     // closed manually for early exits.
     std::unique_ptr<base::SharedMemory> output_shm(
         new base::SharedMemory(params.output_video_frame_handle, false));
     if (!output_shm->Map(params.output_buffer_size)) {
       LOG(ERROR) << "Could not map output shared memory for input buffer id "
                  << params.input_buffer.id();
-      NotifyDecodeStatusOnIOThread(
-          *route_id, params.input_buffer.id(),
-          media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+      NotifyDecodeStatusOnIOThread(*route_id, params.input_buffer.id(),
+                                   JpegDecodeAccelerator::PLATFORM_FAILURE);
       base::SharedMemory::CloseHandle(params.input_buffer.handle());
       return;
     }
 
     uint8_t* shm_memory = static_cast<uint8_t*>(output_shm->memory());
-    scoped_refptr<media::VideoFrame> frame =
-        media::VideoFrame::WrapExternalSharedMemory(
-            media::PIXEL_FORMAT_I420,          // format
-            params.coded_size,                 // coded_size
-            gfx::Rect(params.coded_size),      // visible_rect
-            params.coded_size,                 // natural_size
-            shm_memory,                        // data
-            params.output_buffer_size,         // data_size
-            params.output_video_frame_handle,  // handle
-            0,                                 // data_offset
-            base::TimeDelta());                // timestamp
+    scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalSharedMemory(
+        PIXEL_FORMAT_I420,                 // format
+        params.coded_size,                 // coded_size
+        gfx::Rect(params.coded_size),      // visible_rect
+        params.coded_size,                 // natural_size
+        shm_memory,                        // data
+        params.output_buffer_size,         // data_size
+        params.output_video_frame_handle,  // handle
+        0,                                 // data_offset
+        base::TimeDelta());                // timestamp
     if (!frame.get()) {
       LOG(ERROR) << "Could not create VideoFrame for input buffer id "
                  << params.input_buffer.id();
-      NotifyDecodeStatusOnIOThread(
-          *route_id, params.input_buffer.id(),
-          media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+      NotifyDecodeStatusOnIOThread(*route_id, params.input_buffer.id(),
+                                   JpegDecodeAccelerator::PLATFORM_FAILURE);
       base::SharedMemory::CloseHandle(params.input_buffer.handle());
       return;
     }
     frame->AddDestructionObserver(
         base::Bind(DecodeFinished, base::Passed(&output_shm)));
 
     DCHECK_GT(client_map_.count(*route_id), 0u);
     Client* client = client_map_[*route_id];
     client->Decode(params.input_buffer, frame);
   }
@@ skipping 64 matching lines @@
   // When adding non-chromeos platforms, VideoCaptureGpuJpegDecoder::Initialize
   // needs to be updated.
 
   // This list is ordered by priority of use.
   const GpuJpegDecodeAccelerator::CreateJDAFp create_jda_fps[] = {
       &GpuJpegDecodeAccelerator::CreateV4L2JDA,
       &GpuJpegDecodeAccelerator::CreateVaapiJDA,
   };
 
   std::unique_ptr<Client> client(new Client(this, route_id));
-  std::unique_ptr<media::JpegDecodeAccelerator> accelerator;
+  std::unique_ptr<JpegDecodeAccelerator> accelerator;
   for (const auto& create_jda_function : create_jda_fps) {
-    std::unique_ptr<media::JpegDecodeAccelerator> tmp_accelerator =
+    std::unique_ptr<JpegDecodeAccelerator> tmp_accelerator =
         (*create_jda_function)(io_task_runner_);
     if (tmp_accelerator && tmp_accelerator->Initialize(client.get())) {
       accelerator = std::move(tmp_accelerator);
       break;
     }
   }
 
   if (!accelerator) {
     DLOG(ERROR) << "JPEG accelerator Initialize failed";
     response.Run(false);
@@ skipping 16 matching lines @@
   // we're going to tear down the process anyway. So we just crossed fingers
   // here instead of making the code unnecessary complicated.
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MessageFilter::AddClientOnIOThread, filter_,
                             route_id, client.release(), response));
 }
 
 void GpuJpegDecodeAccelerator::NotifyDecodeStatus(
     int32_t route_id,
     int32_t buffer_id,
-    media::JpegDecodeAccelerator::Error error) {
+    JpegDecodeAccelerator::Error error) {
   DCHECK(CalledOnValidThread());
   Send(new AcceleratedJpegDecoderHostMsg_DecodeAck(route_id, buffer_id, error));
 }
 
 void GpuJpegDecodeAccelerator::ClientRemoved() {
   DCHECK(CalledOnValidThread());
   DCHECK_GT(client_number_, 0);
   client_number_--;
   if (client_number_ == 0) {
     channel_->RemoveFilter(filter_.get());
     filter_ = nullptr;
   }
 }
 
 bool GpuJpegDecodeAccelerator::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   return channel_->Send(message);
 }
 
 // static
-std::unique_ptr<media::JpegDecodeAccelerator>
-GpuJpegDecodeAccelerator::CreateV4L2JDA(
+std::unique_ptr<JpegDecodeAccelerator> GpuJpegDecodeAccelerator::CreateV4L2JDA(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
-  std::unique_ptr<media::JpegDecodeAccelerator> decoder;
+  std::unique_ptr<JpegDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device =
       V4L2Device::Create(V4L2Device::kJpegDecoder);
   if (device)
     decoder.reset(new V4L2JpegDecodeAccelerator(device, io_task_runner));
 #endif
   return decoder;
 }
 
 // static
-std::unique_ptr<media::JpegDecodeAccelerator>
-GpuJpegDecodeAccelerator::CreateVaapiJDA(
+std::unique_ptr<JpegDecodeAccelerator> GpuJpegDecodeAccelerator::CreateVaapiJDA(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
-  std::unique_ptr<media::JpegDecodeAccelerator> decoder;
+  std::unique_ptr<JpegDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   decoder.reset(new VaapiJpegDecodeAccelerator(io_task_runner));
 #endif
   return decoder;
 }
 
 // static
 bool GpuJpegDecodeAccelerator::IsSupported() {
   const GpuJpegDecodeAccelerator::CreateJDAFp create_jda_fps[] = {
       &GpuJpegDecodeAccelerator::CreateV4L2JDA,
       &GpuJpegDecodeAccelerator::CreateVaapiJDA,
   };
   for (const auto& create_jda_function : create_jda_fps) {
-    std::unique_ptr<media::JpegDecodeAccelerator> accelerator =
+    std::unique_ptr<JpegDecodeAccelerator> accelerator =
         (*create_jda_function)(base::ThreadTaskRunnerHandle::Get());
     if (accelerator && accelerator->IsSupported())
       return true;
   }
   return false;
 }
 
 }  // namespace media