Restrict use of hardware-secure codecs based on the RendererPreference.

media/blink/webencryptedmediaclient_impl.cc

 // Copyright 2014 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 "webencryptedmediaclient_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 60 matching lines @@
         KEY_SYSTEM_SUPPORT_STATUS_COUNT + 1,
         base::Histogram::kUmaTargetedHistogramFlag)->Add(status);
   }
 
   const std::string uma_name_;
   bool is_request_reported_;
   bool is_support_reported_;
 };
 
 WebEncryptedMediaClientImpl::WebEncryptedMediaClientImpl(
+    base::Callback<bool(void)> are_secure_codecs_supported_cb,
     CdmFactory* cdm_factory,
     MediaPermission* media_permission)
-    : cdm_factory_(cdm_factory),
+    : are_secure_codecs_supported_cb_(are_secure_codecs_supported_cb),
+      cdm_factory_(cdm_factory),
       key_system_config_selector_(KeySystems::GetInstance(), media_permission),
       weak_factory_(this) {
   DCHECK(cdm_factory_);
 }
 
 WebEncryptedMediaClientImpl::~WebEncryptedMediaClientImpl() {
 }
 
 void WebEncryptedMediaClientImpl::requestMediaKeySystemAccess(
     blink::WebEncryptedMediaRequest request) {
   GetReporter(request.keySystem())->ReportRequested();
   key_system_config_selector_.SelectConfig(
       request.keySystem(), request.supportedConfigurations(),
-      request.securityOrigin(),
+      request.securityOrigin(), are_secure_codecs_supported_cb_.Run(),
       base::Bind(&WebEncryptedMediaClientImpl::OnRequestSucceeded,
                  weak_factory_.GetWeakPtr(), request),
       base::Bind(&WebEncryptedMediaClientImpl::OnRequestNotSupported,
                  weak_factory_.GetWeakPtr(), request));
 }
 
 void WebEncryptedMediaClientImpl::CreateCdm(
     const blink::WebString& key_system,
     bool allow_distinctive_identifier,
     bool allow_persistent_state,
     const blink::WebSecurityOrigin& security_origin,
     blink::WebContentDecryptionModuleResult result) {
   WebContentDecryptionModuleImpl::Create(
       cdm_factory_, key_system, allow_distinctive_identifier,
       allow_persistent_state, security_origin, result);
 }
 
 void WebEncryptedMediaClientImpl::OnRequestSucceeded(
     blink::WebEncryptedMediaRequest request,
-    const blink::WebMediaKeySystemConfiguration& accumulated_configuration) {
+    const blink::WebMediaKeySystemConfiguration& accumulated_configuration,
+    bool are_secure_codecs_required) {
   GetReporter(request.keySystem())->ReportSupported();
+  // TODO(sandersd): Pass |are_secure_codecs_required| along and use it to
+  // configure the CDM security level and use of secure surfaces on Android.
   request.requestSucceeded(WebContentDecryptionModuleAccessImpl::Create(
       request.keySystem(), accumulated_configuration, request.securityOrigin(),
       weak_factory_.GetWeakPtr()));
 }
 
 void WebEncryptedMediaClientImpl::OnRequestNotSupported(
     blink::WebEncryptedMediaRequest request,
     const blink::WebString& error_message) {
   request.requestNotSupported(error_message);
 }
@@ skipping 10 matching lines @@
   std::string uma_name = GetKeySystemNameForUMA(key_system_ascii);
   Reporter* reporter = reporters_.get(uma_name);
   if (!reporter) {
     reporter = new Reporter(uma_name);
     reporters_.add(uma_name, make_scoped_ptr(reporter));
   }
   return reporter;
 }
 
 }  // namespace media