media: Support SetCdm() on VideoDecodeAccelerator interface.

content/common/gpu/media/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 "content/common/gpu/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 133 matching lines @@
   make_context_current_ =
       base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
 }
 
 GpuVideoDecodeAccelerator::~GpuVideoDecodeAccelerator() {
   // This class can only be self-deleted from OnWillDestroyStub(), which means
   // the VDA has already been destroyed in there.
   DCHECK(!video_decode_accelerator_);
 }
 
+// static
+gpu::VideoDecodeAcceleratorSupportedProfiles

[xhwang, 2015/11/13 01:16:55]

here and below, non-cdm methods are moved to fix the order, not code change.

[dcheng, 2015/11/13 19:54:53]

In the future, maybe just do this in a separate patch (either before or after is
fine, just makes the review easier)

[xhwang, 2015/11/13 20:06:22]

Acknowledged.

+GpuVideoDecodeAccelerator::GetSupportedProfiles() {
+  media::VideoDecodeAccelerator::SupportedProfiles profiles;
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
+    return gpu::VideoDecodeAcceleratorSupportedProfiles();
+
+  // Query supported profiles for each VDA. The order of querying VDAs should
+  // be the same as the order of initializing VDAs. Then the returned profile
+  // can be initialized by corresponding VDA successfully.
+#if defined(OS_WIN)
+  profiles = DXVAVideoDecodeAccelerator::GetSupportedProfiles();
+#elif defined(OS_CHROMEOS)
+  media::VideoDecodeAccelerator::SupportedProfiles vda_profiles;
+#if defined(USE_V4L2_CODEC)
+  vda_profiles = V4L2VideoDecodeAccelerator::GetSupportedProfiles();
+  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(vda_profiles, &profiles);
+  vda_profiles = V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles();
+  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(vda_profiles, &profiles);
+#endif
+#if defined(ARCH_CPU_X86_FAMILY)
+  vda_profiles = VaapiVideoDecodeAccelerator::GetSupportedProfiles();
+  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(vda_profiles, &profiles);
+#endif
+#elif defined(OS_MACOSX)
+  profiles = VTVideoDecodeAccelerator::GetSupportedProfiles();
+#elif defined(OS_ANDROID)
+  profiles = AndroidVideoDecodeAccelerator::GetSupportedProfiles();
+#endif
+  return GpuVideoAcceleratorUtil::ConvertMediaToGpuDecodeProfiles(profiles);
+}
+
 bool GpuVideoDecodeAccelerator::OnMessageReceived(const IPC::Message& msg) {
   if (!video_decode_accelerator_)
     return false;
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAccelerator, msg)
+    IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_SetCdm, OnSetCdm)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Decode, OnDecode)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_AssignPictureBuffers,
                         OnAssignPictureBuffers)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_ReusePictureBuffer,
                         OnReusePictureBuffer)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Flush, OnFlush)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Reset, OnReset)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Destroy, OnDestroy)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+void GpuVideoDecodeAccelerator::NotifyCdmAttached(bool success) {
+  if (!Send(new AcceleratedVideoDecoderHostMsg_CdmAttached(host_route_id_,
+                                                           success)))
+    DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_CdmAttached) failed";
+}
+
 void GpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
   if (dimensions.width() > media::limits::kMaxDimension ||
       dimensions.height() > media::limits::kMaxDimension ||
       dimensions.GetArea() > media::limits::kMaxCanvas) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
@@ skipping 35 matching lines @@
   }
 
   if (!Send(new AcceleratedVideoDecoderHostMsg_PictureReady(
           host_route_id_, picture.picture_buffer_id(),
           picture.bitstream_buffer_id(), picture.visible_rect(),
           picture.allow_overlay()))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_PictureReady) failed";
   }
 }
 
+void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
+    int32 bitstream_buffer_id) {
+  if (!Send(new AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed(
+          host_route_id_, bitstream_buffer_id))) {
+    DLOG(ERROR)
+        << "Send(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed) "
+        << "failed";
+  }
+}
+
+void GpuVideoDecodeAccelerator::NotifyFlushDone() {
+  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) {
   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
+  // cleanup. We cannot destroy the VDA before the IO thread message filter is
+  // removed however, since we cannot service incoming messages with VDA gone.
+  // We cannot simply check for existence of VDA on IO thread though, because
+  // we don't want to synchronize the IO thread with the ChildThread.
+  // So we have to wait for the RemoveFilter callback here instead and remove
+  // the VDA after it arrives and before returning.
+  if (filter_.get()) {

[dcheng, 2015/11/13 19:54:53]

No .get() (unless you end up moving this code in a separate patch, then just
leave this alone I guess)

[xhwang, 2015/11/13 20:06:22]

Done.

+    stub_->channel()->RemoveFilter(filter_.get());
+    filter_removed_.Wait();
+  }
+
+  stub_->channel()->RemoveRoute(host_route_id_);
+  stub_->RemoveDestructionObserver(this);
+
+  video_decode_accelerator_.reset();
+  delete this;
+}
+
+bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
+  if (filter_.get() && io_task_runner_->BelongsToCurrentThread())

[dcheng, 2015/11/13 19:54:53]

Ditto

[xhwang, 2015/11/13 20:06:22]

Done.

+    return filter_->SendOnIOThread(message);
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  return stub_->channel()->Send(message);
+}
+
 void GpuVideoDecodeAccelerator::Initialize(
     const media::VideoCodecProfile profile,
     IPC::Message* init_done_msg) {
   DCHECK(!video_decode_accelerator_.get());
 
   if (!stub_->channel()->AddRoute(host_route_id_, this)) {
     DLOG(ERROR) << "Initialize(): failed to add route";
     SendCreateDecoderReply(init_done_msg, false);
   }
 
@@ skipping 143 matching lines @@
 #if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
           new AndroidDeferredRenderingBackingStrategy()
 #else
           new AndroidCopyingBackingStrategy()
 #endif
               )));
 #endif
   return decoder.Pass();
 }
 
-// static
-gpu::VideoDecodeAcceleratorSupportedProfiles
-GpuVideoDecodeAccelerator::GetSupportedProfiles() {
-  media::VideoDecodeAccelerator::SupportedProfiles profiles;
-  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-  if (cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
-    return gpu::VideoDecodeAcceleratorSupportedProfiles();
-
-  // Query supported profiles for each VDA. The order of querying VDAs should
-  // be the same as the order of initializing VDAs. Then the returned profile
-  // can be initialized by corresponding VDA successfully.
-#if defined(OS_WIN)
-  profiles = DXVAVideoDecodeAccelerator::GetSupportedProfiles();
-#elif defined(OS_CHROMEOS)
-  media::VideoDecodeAccelerator::SupportedProfiles vda_profiles;
-#if defined(USE_V4L2_CODEC)
-  vda_profiles = V4L2VideoDecodeAccelerator::GetSupportedProfiles();
-  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(vda_profiles, &profiles);
-  vda_profiles = V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles();
-  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(vda_profiles, &profiles);
-#endif
-#if defined(ARCH_CPU_X86_FAMILY)
-  vda_profiles = VaapiVideoDecodeAccelerator::GetSupportedProfiles();
-  GpuVideoAcceleratorUtil::InsertUniqueDecodeProfiles(vda_profiles, &profiles);
-#endif
-#elif defined(OS_MACOSX)
-  profiles = VTVideoDecodeAccelerator::GetSupportedProfiles();
-#elif defined(OS_ANDROID)
-  profiles = AndroidVideoDecodeAccelerator::GetSupportedProfiles();
-#endif
-  return GpuVideoAcceleratorUtil::ConvertMediaToGpuDecodeProfiles(profiles);
+void GpuVideoDecodeAccelerator::OnSetCdm(int cdm_id) {
+  DCHECK(video_decode_accelerator_.get());

[dcheng, 2015/11/13 19:54:53]

No .get()

[xhwang, 2015/11/13 20:06:22]

Done.

+  video_decode_accelerator_->SetCdm(cdm_id);
 }
 
 // Runs on IO thread if video_decode_accelerator_->CanDecodeOnIOThread() is
 // true, otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
     const AcceleratedVideoDecoderMsg_Decode_Params& params) {
   DCHECK(video_decode_accelerator_.get());
   if (params.bitstream_buffer_id < 0) {
     DLOG(ERROR) << "BitstreamBuffer id " << params.bitstream_buffer_id
                 << " out of range";
@@ skipping 112 matching lines @@
   DCHECK(video_decode_accelerator_.get());
   OnWillDestroyStub();
 }
 
 void GpuVideoDecodeAccelerator::OnFilterRemoved() {
   // We're destroying; cancel all callbacks.
   weak_factory_for_io_.InvalidateWeakPtrs();
   filter_removed_.Signal();
 }
 
-void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
-    int32 bitstream_buffer_id) {
-  if (!Send(new AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed(
-          host_route_id_, bitstream_buffer_id))) {
-    DLOG(ERROR)
-        << "Send(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed) "
-        << "failed";
-  }
-}
-
-void GpuVideoDecodeAccelerator::NotifyFlushDone() {
-  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::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
-  // cleanup. We cannot destroy the VDA before the IO thread message filter is
-  // removed however, since we cannot service incoming messages with VDA gone.
-  // We cannot simply check for existence of VDA on IO thread though, because
-  // we don't want to synchronize the IO thread with the ChildThread.
-  // So we have to wait for the RemoveFilter callback here instead and remove
-  // the VDA after it arrives and before returning.
-  if (filter_.get()) {
-    stub_->channel()->RemoveFilter(filter_.get());
-    filter_removed_.Wait();
-  }
-
-  stub_->channel()->RemoveRoute(host_route_id_);
-  stub_->RemoveDestructionObserver(this);
-
-  video_decode_accelerator_.reset();
-  delete this;
-}
-
 void GpuVideoDecodeAccelerator::SetTextureCleared(
     const media::Picture& picture) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DebugAutoLock auto_lock(debug_uncleared_textures_lock_);
   std::map<int32, scoped_refptr<gpu::gles2::TextureRef> >::iterator it;
   it = uncleared_textures_.find(picture.picture_buffer_id());
   if (it == uncleared_textures_.end())
     return;  // the texture has been cleared
 
   scoped_refptr<gpu::gles2::TextureRef> 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);
 }
 
-bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
-  if (filter_.get() && io_task_runner_->BelongsToCurrentThread())
-    return filter_->SendOnIOThread(message);
-  DCHECK(child_task_runner_->BelongsToCurrentThread());
-  return stub_->channel()->Send(message);
-}
-
 void GpuVideoDecodeAccelerator::SendCreateDecoderReply(IPC::Message* message,
                                                        bool succeeded) {
   GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(message, succeeded);
   Send(message);
 }
 
 }  // namespace content