Pass DecryptConfig parameters over IPC and use it in AVDA.

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 415 matching lines @@
   profiles = VTVideoDecodeAccelerator::GetSupportedProfiles();
 #elif defined(OS_ANDROID)
   profiles = AndroidVideoDecodeAccelerator::GetSupportedProfiles();
 #endif
   return GpuVideoAcceleratorUtil::ConvertMediaToGpuDecodeProfiles(profiles);
 }
 
 // Runs on IO thread if video_decode_accelerator_->CanDecodeOnIOThread() is
 // true, otherwise on the main thread.
 void GpuVideoDecodeAccelerator::OnDecode(
-    base::SharedMemoryHandle handle,
-    int32 id,
-    uint32 size,
-    base::TimeDelta presentation_timestamp) {
+    const AcceleratedVideoDecoderMsg_Decode_Params& params) {
   DCHECK(video_decode_accelerator_.get());
-  if (id < 0) {
-    DLOG(ERROR) << "BitstreamBuffer id " << id << " out of range";
+  if (params.bitstream_buffer_id < 0) {
+    DLOG(ERROR) << "BitstreamBuffer id " << params.bitstream_buffer_id
+                << " out of range";
     if (child_task_runner_->BelongsToCurrentThread()) {
       NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
     } else {
       child_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&GpuVideoDecodeAccelerator::NotifyError,
                      base::Unretained(this),
                      media::VideoDecodeAccelerator::INVALID_ARGUMENT));
     }
     return;
   }
-  video_decode_accelerator_->Decode(
-      media::BitstreamBuffer(id, handle, size, presentation_timestamp));
+
+  media::BitstreamBuffer bitstream_buffer(params.bitstream_buffer_id,
+                                          params.buffer_handle, params.size,
+                                          params.presentation_timestamp);
+  if (!params.key_id.empty()) {
+    bitstream_buffer.SetDecryptConfig(
+        media::DecryptConfig(params.key_id, params.iv, params.subsamples));
+  }
+
+  video_decode_accelerator_->Decode(bitstream_buffer);
 }
 
 void GpuVideoDecodeAccelerator::OnAssignPictureBuffers(
     const std::vector<int32>& buffer_ids,
     const std::vector<uint32>& texture_ids) {
   if (buffer_ids.size() != texture_ids.size()) {
     NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
     return;
   }
 
@@ skipping 154 matching lines @@
   return stub_->channel()->Send(message);
 }
 
 void GpuVideoDecodeAccelerator::SendCreateDecoderReply(IPC::Message* message,
                                                        bool succeeded) {
   GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(message, succeeded);
   Send(message);
 }
 
 }  // namespace content