Migrate content/common/gpu/media code to media/gpu

media/gpu/ipc/service/gpu_video_encode_accelerator.cc

 // 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.
 
-#include "content/common/gpu/media/gpu_video_encode_accelerator.h"
+#include "media/gpu/ipc/service/gpu_video_encode_accelerator.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/numerics/safe_math.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/gpu/ipc/common/gpu_video_accelerator_util.h"
 #include "media/gpu/ipc/common/media_messages.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
-#include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
+#include "media/gpu/v4l2_video_encode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
-#include "content/common/gpu/media/vaapi_video_encode_accelerator.h"
+#include "media/gpu/vaapi_video_encode_accelerator.h"
 #endif
 #elif defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
-#include "content/common/gpu/media/android_video_encode_accelerator.h"
+#include "media/gpu/android_video_encode_accelerator.h"
 #elif defined(OS_MACOSX)
-#include "content/common/gpu/media/vt_video_encode_accelerator_mac.h"
+#include "media/gpu/vt_video_encode_accelerator_mac.h"
 #endif
 
-namespace content {
+namespace media {
 
 static bool MakeDecoderContextCurrent(
     const base::WeakPtr<gpu::GpuCommandBufferStub> stub) {
   if (!stub) {
     DLOG(ERROR) << "Stub is gone; won't MakeCurrent().";
     return false;
   }
 
   if (!stub->decoder()->MakeCurrent()) {
     DLOG(ERROR) << "Failed to MakeCurrent()";
@@ skipping 21 matching lines @@
   // the VEA has already been destroyed in there.
   DCHECK(!encoder_);
 }
 
 bool GpuVideoEncodeAccelerator::Initialize(
     media::VideoPixelFormat input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
     uint32_t initial_bitrate) {
   DVLOG(2) << "GpuVideoEncodeAccelerator::Initialize(): "
-              "input_format=" << input_format
+              "input_format="
+           << input_format
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
   DCHECK(!encoder_);
 
   if (!stub_->channel()->AddRoute(host_route_id_, stub_->stream_id(), this)) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
                    "failed to add route";
     return false;
   }
 
   if (input_visible_size.width() > media::limits::kMaxDimension ||
       input_visible_size.height() > media::limits::kMaxDimension ||
       input_visible_size.GetArea() > media::limits::kMaxCanvas) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::Initialize(): "
-                   "input_visible_size " << input_visible_size.ToString()
-                << " too large";
+                   "input_visible_size "
+                << input_visible_size.ToString() << " too large";
     return false;
   }
 
   const gpu::GpuPreferences& gpu_preferences =
       stub_->channel()->gpu_channel_manager()->gpu_preferences();
 
   std::vector<GpuVideoEncodeAccelerator::CreateVEAFp> create_vea_fps =
       CreateVEAFps(gpu_preferences);
   // Try all possible encoders and use the first successful encoder.
   for (size_t i = 0; i < create_vea_fps.size(); ++i) {
     encoder_ = (*create_vea_fps[i])();
-    if (encoder_ && encoder_->Initialize(input_format,
-                                         input_visible_size,
-                                         output_profile,
-                                         initial_bitrate,
-                                         this)) {
+    if (encoder_ &&
+        encoder_->Initialize(input_format, input_visible_size, output_profile,
+                             initial_bitrate, this)) {
       input_format_ = input_format;
       input_visible_size_ = input_visible_size;
       return true;
     }
   }
   encoder_.reset();
   DLOG(ERROR)
       << "GpuVideoEncodeAccelerator::Initialize(): VEA initialization failed";
   return false;
 }
@@ skipping 138 matching lines @@
   // Wrap into a SharedMemory in the beginning, so that |params.buffer_handle|
   // is cleaned properly in case of an early return.
   std::unique_ptr<base::SharedMemory> shm(
       new base::SharedMemory(params.buffer_handle, true));
 
   if (!encoder_)
     return;
 
   if (params.frame_id < 0) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): invalid "
-                   "frame_id=" << params.frame_id;
+                   "frame_id="
+                << params.frame_id;
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
   const uint32_t aligned_offset =
       params.buffer_offset % base::SysInfo::VMAllocationGranularity();
   base::CheckedNumeric<off_t> map_offset = params.buffer_offset;
   map_offset -= aligned_offset;
   base::CheckedNumeric<size_t> map_size = params.buffer_size;
   map_size += aligned_offset;
 
   if (!map_offset.IsValid() || !map_size.IsValid()) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode():"
                 << " invalid (buffer_offset,buffer_size)";
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
   if (!shm->MapAt(map_offset.ValueOrDie(), map_size.ValueOrDie())) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): "
                 << "could not map frame_id=" << params.frame_id;
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
 
   uint8_t* shm_memory =
       reinterpret_cast<uint8_t*>(shm->memory()) + aligned_offset;
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalSharedMemory(
-          input_format_,
-          input_coded_size_,
-          gfx::Rect(input_visible_size_),
-          input_visible_size_,
-          shm_memory,
-          params.buffer_size,
-          params.buffer_handle,
-          params.buffer_offset,
-          params.timestamp);
+          input_format_, input_coded_size_, gfx::Rect(input_visible_size_),
+          input_visible_size_, shm_memory, params.buffer_size,
+          params.buffer_handle, params.buffer_offset, params.timestamp);
   if (!frame) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnEncode(): "
                 << "could not create a frame";
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
-  frame->AddDestructionObserver(
-      media::BindToCurrentLoop(
-          base::Bind(&GpuVideoEncodeAccelerator::EncodeFrameFinished,
-                     weak_this_factory_.GetWeakPtr(),
-                     params.frame_id,
-                     base::Passed(&shm))));
+  frame->AddDestructionObserver(media::BindToCurrentLoop(base::Bind(
+      &GpuVideoEncodeAccelerator::EncodeFrameFinished,
+      weak_this_factory_.GetWeakPtr(), params.frame_id, base::Passed(&shm))));
   encoder_->Encode(frame, params.force_keyframe);
 }
 
 void GpuVideoEncodeAccelerator::OnEncode2(
     const AcceleratedVideoEncoderMsg_Encode_Params2& params) {
   DVLOG(3) << "GpuVideoEncodeAccelerator::OnEncode2: frame_id = "
            << params.frame_id << ", size=" << params.size.ToString()
-           << ", force_keyframe=" << params.force_keyframe << ", handle type="
-           << params.gpu_memory_buffer_handles[0].type;
+           << ", force_keyframe=" << params.force_keyframe
+           << ", handle type=" << params.gpu_memory_buffer_handles[0].type;
   // Encoding GpuMemoryBuffer backed frames is not supported.
   NOTREACHED();
 }
 
 void GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(
     int32_t buffer_id,
     base::SharedMemoryHandle buffer_handle,
     uint32_t buffer_size) {
   DVLOG(3) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
-              "buffer_id=" << buffer_id
-           << ", buffer_size=" << buffer_size;
+              "buffer_id="
+           << buffer_id << ", buffer_size=" << buffer_size;
   if (!encoder_)
     return;
   if (buffer_id < 0) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
-                   "invalid buffer_id=" << buffer_id;
+                   "invalid buffer_id="
+                << buffer_id;
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   if (buffer_size < output_buffer_size_) {
     DLOG(ERROR) << "GpuVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(): "
-                   "buffer too small for buffer_id=" << buffer_id;
+                   "buffer too small for buffer_id="
+                << buffer_id;
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   encoder_->UseOutputBitstreamBuffer(
       media::BitstreamBuffer(buffer_id, buffer_handle, buffer_size));
 }
 
 void GpuVideoEncodeAccelerator::OnDestroy() {
   DVLOG(2) << "GpuVideoEncodeAccelerator::OnDestroy()";
   OnWillDestroyStub();
 }
 
 void GpuVideoEncodeAccelerator::OnRequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(2) << "GpuVideoEncodeAccelerator::OnRequestEncodingParametersChange(): "
-              "bitrate=" << bitrate
-           << ", framerate=" << framerate;
+              "bitrate="
+           << bitrate << ", framerate=" << framerate;
   if (!encoder_)
     return;
   encoder_->RequestEncodingParametersChange(bitrate, framerate);
 }
 
 void GpuVideoEncodeAccelerator::EncodeFrameFinished(
     int32_t frame_id,
     std::unique_ptr<base::SharedMemory> shm) {
   Send(new AcceleratedVideoEncoderHostMsg_NotifyInputDone(host_route_id_,
                                                           frame_id));
   // Just let |shm| fall out of scope.
 }
 
 void GpuVideoEncodeAccelerator::Send(IPC::Message* message) {
   stub_->channel()->Send(message);
 }
 
-}  // namespace content
+}  // namespace media