Passed is_encrypted parameter to the VDA initialization.

content/common/gpu/media/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 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 <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
@@ skipping 415 matching lines @@
                               weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
-bool V4L2SliceVideoDecodeAccelerator::Initialize(
-    media::VideoCodecProfile profile,
-    VideoDecodeAccelerator::Client* client) {
-  DVLOGF(3) << "profile: " << profile;
+bool V4L2SliceVideoDecodeAccelerator::Initialize(const Config& config,
+                                                 Client* client) {
+  DVLOGF(3) << "profile: " << config.profile;
+  if (config.is_encrypted) {
+    NOTREACHED() << "Encrypted streams are not supported for this VDA";
+    return false;
+  }
+
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kUninitialized);
 
   client_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator::Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
 
-  video_profile_ = profile;
+  video_profile_ = config.profile;
 
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     h264_accelerator_.reset(new V4L2H264Accelerator(this));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
   } else if (video_profile_ >= media::VP8PROFILE_MIN &&
              video_profile_ <= media::VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new V4L2VP8Accelerator(this));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
   } else {
@@ skipping 2081 matching lines @@
   if (!device)
     return SupportedProfiles();
 
   const uint32_t supported_formats[] = {
       V4L2_PIX_FMT_H264_SLICE, V4L2_PIX_FMT_VP8_FRAME};
   return device->GetSupportedDecodeProfiles(arraysize(supported_formats),
                                             supported_formats);
 }
 
 }  // namespace content