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

media/gpu/ipc/service/gpu_video_decode_accelerator.cc

 // Copyright (c) 2012 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_video_decode_accelerator.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 205 matching lines @@
     DLOG(ERROR)
         << "Send(AcceleratedVideoDecoderHostMsg_InitializationComplete) failed";
 }
 
 void GpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
     VideoPixelFormat format,
     uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
-  if (dimensions.width() > media::limits::kMaxDimension ||
-      dimensions.height() > media::limits::kMaxDimension ||
-      dimensions.GetArea() > media::limits::kMaxCanvas) {
-    NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
+  if (dimensions.width() > limits::kMaxDimension ||
+      dimensions.height() > limits::kMaxDimension ||
+      dimensions.GetArea() > limits::kMaxCanvas) {
+    NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   if (!Send(new AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers(
           host_route_id_, requested_num_of_buffers, format, textures_per_buffer,
           dimensions, texture_target))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ProvidePictureBuffers) "
                 << "failed";
   }
   texture_dimensions_ = dimensions;
   textures_per_buffer_ = textures_per_buffer;
   texture_target_ = texture_target;
 }
 
 void GpuVideoDecodeAccelerator::DismissPictureBuffer(
     int32_t picture_buffer_id) {
   // Notify client that picture buffer is now unused.
   if (!Send(new AcceleratedVideoDecoderHostMsg_DismissPictureBuffer(
           host_route_id_, picture_buffer_id))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_DismissPictureBuffer) "
                 << "failed";
   }
   DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
   uncleared_textures_.erase(picture_buffer_id);
 }
 
-void GpuVideoDecodeAccelerator::PictureReady(const media::Picture& picture) {
+void GpuVideoDecodeAccelerator::PictureReady(const Picture& picture) {
   // VDA may call PictureReady on IO thread. SetTextureCleared should run on
   // the child thread. VDA is responsible to call PictureReady on the child
   // thread when a picture buffer is delivered the first time.
   if (child_task_runner_->BelongsToCurrentThread()) {
     SetTextureCleared(picture);
   } else {
     DCHECK(io_task_runner_->BelongsToCurrentThread());
     DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
     DCHECK_EQ(0u, uncleared_textures_.count(picture.picture_buffer_id()));
   }
@@ skipping 20 matching lines @@
   if (!Send(new AcceleratedVideoDecoderHostMsg_FlushDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_FlushDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::NotifyResetDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ResetDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ResetDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::NotifyError(
-    media::VideoDecodeAccelerator::Error error) {
+    VideoDecodeAccelerator::Error error) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ErrorNotification(host_route_id_,
                                                                  error))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ErrorNotification) "
                 << "failed";
   }
 }
 
 void GpuVideoDecodeAccelerator::OnWillDestroyStub() {
   // The stub is going away, so we have to stop and destroy VDA here, before
   // returning, because the VDA may need the GL context to run and/or do its
@@ skipping 16 matching lines @@
 }
 
 bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
   if (filter_ && io_task_runner_->BelongsToCurrentThread())
     return filter_->SendOnIOThread(message);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   return stub_->channel()->Send(message);
 }
 
 bool GpuVideoDecodeAccelerator::Initialize(
-    const media::VideoDecodeAccelerator::Config& config) {
+    const VideoDecodeAccelerator::Config& config) {
   DCHECK(!video_decode_accelerator_);
 
   if (!stub_->channel()->AddRoute(host_route_id_, stub_->stream_id(), this)) {
     DLOG(ERROR) << "Initialize(): failed to add route";
     return false;
   }
 
 #if !defined(OS_WIN)
   // Ensure we will be able to get a GL context at all before initializing
   // non-Windows VDAs.
@@ skipping 28 matching lines @@
     filter_ = new MessageFilter(this, host_route_id_);
     stub_->channel()->AddFilter(filter_.get());
   }
 
   return true;
 }
 
 // Runs on IO thread if VDA::TryToSetupDecodeOnSeparateThread() succeeded,
 // otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   DCHECK(video_decode_accelerator_);
   video_decode_accelerator_->Decode(bitstream_buffer);
 }
 
 void GpuVideoDecodeAccelerator::OnAssignPictureBuffers(
     const std::vector<int32_t>& buffer_ids,
-    const std::vector<media::PictureBuffer::TextureIds>& texture_ids) {
+    const std::vector<PictureBuffer::TextureIds>& texture_ids) {
   if (buffer_ids.size() != texture_ids.size()) {
-    NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+    NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
     return;
   }
 
   gpu::gles2::GLES2Decoder* command_decoder = stub_->decoder();
   gpu::gles2::TextureManager* texture_manager =
       command_decoder->GetContextGroup()->texture_manager();
 
-  std::vector<media::PictureBuffer> buffers;
+  std::vector<PictureBuffer> buffers;
   std::vector<std::vector<scoped_refptr<gpu::gles2::TextureRef>>> textures;
   for (uint32_t i = 0; i < buffer_ids.size(); ++i) {
     if (buffer_ids[i] < 0) {
       DLOG(ERROR) << "Buffer id " << buffer_ids[i] << " out of range";
-      NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+      NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
     std::vector<scoped_refptr<gpu::gles2::TextureRef>> current_textures;
-    media::PictureBuffer::TextureIds buffer_texture_ids = texture_ids[i];
-    media::PictureBuffer::TextureIds service_ids;
+    PictureBuffer::TextureIds buffer_texture_ids = texture_ids[i];
+    PictureBuffer::TextureIds service_ids;
     if (buffer_texture_ids.size() != textures_per_buffer_) {
       DLOG(ERROR) << "Requested " << textures_per_buffer_
                   << " textures per picture buffer, got "
                   << buffer_texture_ids.size();
-      NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+      NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
       return;
     }
     for (size_t j = 0; j < textures_per_buffer_; j++) {
       gpu::gles2::TextureRef* texture_ref =
           texture_manager->GetTexture(buffer_texture_ids[j]);
       if (!texture_ref) {
         DLOG(ERROR) << "Failed to find texture id " << buffer_texture_ids[j];
-        NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+        NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
         return;
       }
       gpu::gles2::Texture* info = texture_ref->texture();
       if (info->target() != texture_target_) {
         DLOG(ERROR) << "Texture target mismatch for texture id "
                     << buffer_texture_ids[j];
-        NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+        NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
         return;
       }
       if (texture_target_ == GL_TEXTURE_EXTERNAL_OES ||
           texture_target_ == GL_TEXTURE_RECTANGLE_ARB) {
         // These textures have their dimensions defined by the underlying
         // storage.
         // Use |texture_dimensions_| for this size.
         texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, GL_RGBA,
                                       texture_dimensions_.width(),
                                       texture_dimensions_.height(), 1, 0,
                                       GL_RGBA, 0, gfx::Rect());
       } else {
         // For other targets, texture dimensions should already be defined.
         GLsizei width = 0, height = 0;
         info->GetLevelSize(texture_target_, 0, &width, &height, nullptr);
         if (width != texture_dimensions_.width() ||
             height != texture_dimensions_.height()) {
           DLOG(ERROR) << "Size mismatch for texture id "
                       << buffer_texture_ids[j];
-          NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
+          NotifyError(VideoDecodeAccelerator::INVALID_ARGUMENT);
           return;
         }
 
         // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
         GLenum format =
             video_decode_accelerator_.get()->GetSurfaceInternalFormat();
         if (format != GL_RGBA) {
           texture_manager->SetLevelInfo(texture_ref, texture_target_, 0, format,
                                         width, height, 1, 0, format, 0,
                                         gfx::Rect());
         }
       }
       service_ids.push_back(texture_ref->service_id());
       current_textures.push_back(texture_ref);
     }
     textures.push_back(current_textures);
-    buffers.push_back(media::PictureBuffer(buffer_ids[i], texture_dimensions_,
-                                           service_ids, buffer_texture_ids));
+    buffers.push_back(PictureBuffer(buffer_ids[i], texture_dimensions_,
+                                    service_ids, buffer_texture_ids));
   }
   {
     DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
     for (uint32_t i = 0; i < buffer_ids.size(); ++i)
       uncleared_textures_[buffer_ids[i]] = textures[i];
   }
   video_decode_accelerator_->AssignPictureBuffers(buffers);
 }
 
 void GpuVideoDecodeAccelerator::OnReusePictureBuffer(
@@ skipping 16 matching lines @@
   DCHECK(video_decode_accelerator_);
   OnWillDestroyStub();
 }
 
 void GpuVideoDecodeAccelerator::OnFilterRemoved() {
   // We're destroying; cancel all callbacks.
   weak_factory_for_io_.InvalidateWeakPtrs();
   filter_removed_.Signal();
 }
 
-void GpuVideoDecodeAccelerator::SetTextureCleared(
-    const media::Picture& picture) {
+void GpuVideoDecodeAccelerator::SetTextureCleared(const Picture& picture) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
   auto it = uncleared_textures_.find(picture.picture_buffer_id());
   if (it == uncleared_textures_.end())
     return;  // the texture has been cleared
 
   for (auto texture_ref : it->second) {
     GLenum target = texture_ref->texture()->target();
     gpu::gles2::TextureManager* texture_manager =
         stub_->decoder()->GetContextGroup()->texture_manager();
     DCHECK(!texture_ref->texture()->IsLevelCleared(target, 0));
     texture_manager->SetLevelCleared(texture_ref.get(), target, 0, true);
   }
   uncleared_textures_.erase(it);
 }
 
 }  // namespace media