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 146 matching lines @@
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAccelerator, msg)
     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_SetCdm, OnSetCdm)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Destroy, OnDestroy)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void GpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
@@ skipping 365 matching lines @@
 void GpuVideoDecodeAccelerator::OnFlush() {
   DCHECK(video_decode_accelerator_.get());
   video_decode_accelerator_->Flush();
 }
 
 void GpuVideoDecodeAccelerator::OnReset() {
   DCHECK(video_decode_accelerator_.get());
   video_decode_accelerator_->Reset();
 }
 
+void GpuVideoDecodeAccelerator::OnSetCdm(int cdm_id) {
+  DCHECK(video_decode_accelerator_.get());

[dcheng, 2015/11/12 18:48:43]

Nit: no .get() when testing a smart pointer

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

Done.

+  video_decode_accelerator_->SetCdm(cdm_id);
+}
+
 void GpuVideoDecodeAccelerator::OnDestroy() {
   DCHECK(video_decode_accelerator_.get());
   OnWillDestroyStub();
 }
 
 void GpuVideoDecodeAccelerator::OnFilterRemoved() {
   // We're destroying; cancel all callbacks.
   weak_factory_for_io_.InvalidateWeakPtrs();
   filter_removed_.Signal();
 }
@@ skipping 11 matching lines @@
 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::NotifyCdmSet(bool success) {
+  if (!Send(new AcceleratedVideoDecoderHostMsg_CdmSet(host_route_id_, success)))
+    DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_CdmSet) 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()) {
@@ skipping 33 matching lines @@
   return stub_->channel()->Send(message);
 }
 
 void GpuVideoDecodeAccelerator::SendCreateDecoderReply(IPC::Message* message,
                                                        bool succeeded) {
   GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(message, succeeded);
   Send(message);
 }
 
 }  // namespace content