Expose encrypted_only attribute on VDA supported profiles.

media/filters/gpu_video_decoder.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 "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 150 matching lines @@
   // TODO(posciak): destroy and create a new VDA on codec/profile change
   // (http://crbug.com/260224).
   if (previously_initialized && (config_.profile() != config.profile())) {
     DVLOG(1) << "Codec or profile changed, cannot reinitialize.";
     bound_init_cb.Run(false);
     return;
   }
 
   VideoDecodeAccelerator::Capabilities capabilities =
       factories_->GetVideoDecodeAcceleratorCapabilities();
-  if (!IsProfileSupported(capabilities, config.profile(),
-                          config.coded_size())) {
-    DVLOG(1) << "Profile " << config.profile() << " or coded size "
-             << config.coded_size().ToString() << " not supported.";
+  if (!IsProfileSupported(capabilities, config.profile(), config.coded_size(),
+                          config.is_encrypted())) {
+    DVLOG(1) << "Unsupported profile " << config.profile()
+             << ", unsupported coded size " << config.coded_size().ToString()
+             << ", or accelerator should only be used for encrypted content. "
+             << " is_encrypted: " << (config.is_encrypted() ? "yes." : "no.");
     bound_init_cb.Run(false);
     return;
   }
 
   config_ = config;
   needs_all_picture_buffers_to_decode_ =
       capabilities.flags &
       VideoDecodeAccelerator::Capabilities::NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
   output_cb_ = BindToCurrentLoop(output_cb);
@@ skipping 516 matching lines @@
     bitstream_buffers_in_decoder_.erase(it);
   }
 
   DLOG(ERROR) << "VDA Error: " << error;
   DestroyVDA();
 }
 
 bool GpuVideoDecoder::IsProfileSupported(
     const VideoDecodeAccelerator::Capabilities& capabilities,
     VideoCodecProfile profile,
-    const gfx::Size& coded_size) {
+    const gfx::Size& coded_size,
+    bool is_encrypted) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   for (const auto& supported_profile : capabilities.supported_profiles) {
     if (profile == supported_profile.profile) {
+      if (supported_profile.encrypted_only && !is_encrypted)
+        continue;
+
       return IsCodedSizeSupported(coded_size,
                                   supported_profile.min_resolution,
                                   supported_profile.max_resolution);
     }
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media