Plumb |use_secure_codecs| through to BrowserCdmFactoryAndroid.

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 87 matching lines @@
       request.keySystem(), request.supportedConfigurations(),
       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,
+    const CdmConfig& cdm_config,
     blink::WebContentDecryptionModuleResult result) {
   WebContentDecryptionModuleImpl::Create(
-      cdm_factory_, key_system, allow_distinctive_identifier,
-      allow_persistent_state, security_origin, result);
+      cdm_factory_, key_system, security_origin, cdm_config, result);
 }
 
 void WebEncryptedMediaClientImpl::OnRequestSucceeded(
     blink::WebEncryptedMediaRequest request,
     const blink::WebMediaKeySystemConfiguration& accumulated_configuration,
-    bool are_secure_codecs_required) {
+    const CdmConfig& cdm_config) {
   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()));
+      request.keySystem(), request.securityOrigin(), accumulated_configuration,
+      cdm_config, weak_factory_.GetWeakPtr()));
 }
 
 void WebEncryptedMediaClientImpl::OnRequestNotSupported(
     blink::WebEncryptedMediaRequest request,
     const blink::WebString& error_message) {
   request.requestNotSupported(error_message);
 }
 
 WebEncryptedMediaClientImpl::Reporter* WebEncryptedMediaClientImpl::GetReporter(
     const blink::WebString& key_system) {
   // Assumes that empty will not be found by GetKeySystemNameForUMA().
   // TODO(sandersd): Avoid doing ASCII conversion more than once.
   std::string key_system_ascii;
   if (base::IsStringASCII(key_system))
     key_system_ascii = base::UTF16ToASCII(key_system);
 
   // Return a per-frame singleton so that UMA reports will be once-per-frame.
   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