Passed is_encrypted parameter to the VDA initialization.

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 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/android_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 63 matching lines @@
   return base::TimeDelta::FromMicroseconds(0);
 }
 
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
     const base::WeakPtr<gpu::gles2::GLES2Decoder> decoder,
     const base::Callback<bool(void)>& make_context_current,
     scoped_ptr<BackingStrategy> strategy)
     : client_(NULL),
       make_context_current_(make_context_current),
       codec_(media::kCodecH264),
+      is_encrypted_(false),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       gl_decoder_(decoder),
       strategy_(strategy.Pass()),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-bool AndroidVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
+bool AndroidVideoDecodeAccelerator::Initialize(const Config& config,
                                                Client* client) {
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Initialize");
 
+  DVLOG(1) << __FUNCTION__ << ": profile:" << config.profile
+           << " is_encrypted:" << config.is_encrypted;
+
   client_ = client;
-  codec_ = VideoCodecProfileToVideoCodec(profile);
+  codec_ = VideoCodecProfileToVideoCodec(config.profile);
+  is_encrypted_ = config.is_encrypted;
 
   bool profile_supported = codec_ == media::kCodecVP8;
 #if defined(ENABLE_MEDIA_PIPELINE_ON_ANDROID)
   profile_supported |=
       (codec_ == media::kCodecVP9 || codec_ == media::kCodecH264);
 #endif
 
   if (!profile_supported) {
-    LOG(ERROR) << "Unsupported profile: " << profile;
+    LOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware.
   if ((codec_ == media::kCodecVP8 || codec_ == media::kCodecVP9) &&
       media::VideoCodecBridge::IsKnownUnaccelerated(
           codec_, media::MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
              << (codec_ == media::kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
@@ skipping 540 matching lines @@
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 #endif
 
   return profiles;
 }
 
 }  // namespace content