Plumb |use_secure_codecs| through to BrowserCdmFactoryAndroid.

media/blink/key_system_config_selector.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 "key_system_config_selector.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "media/base/cdm_config.h"
 #include "media/base/key_systems.h"
 #include "media/base/media_permission.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/public/platform/WebMediaKeySystemConfiguration.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "url/gurl.h"
 
@@ skipping 103 matching lines @@
   return EmeConfigRule::PERSISTENCE_REQUIRED;
 }
 
 }  // namespace
 
 struct KeySystemConfigSelector::SelectionRequest {
   std::string key_system;
   blink::WebVector<blink::WebMediaKeySystemConfiguration>
       candidate_configurations;
   blink::WebSecurityOrigin security_origin;
-  base::Callback<void(const blink::WebMediaKeySystemConfiguration&, bool)>
-      succeeded_cb;
+  base::Callback<void(const blink::WebMediaKeySystemConfiguration&,
+                      const CdmConfig&)> succeeded_cb;
   base::Callback<void(const blink::WebString&)> not_supported_cb;
   bool was_permission_requested = false;
   bool is_permission_granted = false;
   bool are_secure_codecs_supported = false;
 };
 
 // Accumulates configuration rules to determine if a feature (additional
 // configuration rule) can be added to an accumulated configuration.
 class KeySystemConfigSelector::ConfigState {
  public:
@@ skipping 520 matching lines @@
   // 17. Return accumulated configuration.
   return CONFIGURATION_SUPPORTED;
 }
 
 void KeySystemConfigSelector::SelectConfig(
     const blink::WebString& key_system,
     const blink::WebVector<blink::WebMediaKeySystemConfiguration>&
         candidate_configurations,
     const blink::WebSecurityOrigin& security_origin,
     bool are_secure_codecs_supported,
-    base::Callback<void(const blink::WebMediaKeySystemConfiguration&, bool)>
-        succeeded_cb,
+    base::Callback<void(const blink::WebMediaKeySystemConfiguration&,
+                        const CdmConfig&)> succeeded_cb,
     base::Callback<void(const blink::WebString&)> not_supported_cb) {
   // Continued from requestMediaKeySystemAccess(), step 7, from
   // https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess
   //
   // 7.1. If keySystem is not one of the Key Systems supported by the user
   //      agent, reject promise with with a new DOMException whose name is
   //      NotSupportedError. String comparison is case-sensitive.
   if (!base::IsStringASCII(key_system)) {
     not_supported_cb.Run("Only ASCII keySystems are supported");
     return;
@@ skipping 32 matching lines @@
     //        configuration, and origin.
     // 7.3.3. If supported configuration is not null, [initialize and return a
     //        new MediaKeySystemAccess object.]
     ConfigState config_state(request->was_permission_requested,
                              request->is_permission_granted);
     DCHECK(config_state.IsRuleSupported(
         EmeConfigRule::SECURE_CODECS_NOT_ALLOWED));
     if (!request->are_secure_codecs_supported)
       config_state.AddRule(EmeConfigRule::SECURE_CODECS_NOT_ALLOWED);
     blink::WebMediaKeySystemConfiguration accumulated_configuration;
+    CdmConfig cdm_config;
     ConfigurationSupport support = GetSupportedConfiguration(
         request->key_system, request->candidate_configurations[i],
         &config_state, &accumulated_configuration);
     switch (support) {
       case CONFIGURATION_NOT_SUPPORTED:
         continue;
       case CONFIGURATION_REQUIRES_PERMISSION:
         if (request->was_permission_requested) {
           DVLOG(2) << "Rejecting requested configuration because "
                    << "permission was denied.";
           continue;
         }
         media_permission_->RequestPermission(
             MediaPermission::PROTECTED_MEDIA_IDENTIFIER,
             GURL(request->security_origin.toString()),
             base::Bind(&KeySystemConfigSelector::OnPermissionResult,
                        weak_factory_.GetWeakPtr(), base::Passed(&request)));
         return;
       case CONFIGURATION_SUPPORTED:
-        request->succeeded_cb.Run(accumulated_configuration,
-                                  config_state.AreSecureCodecsRequired());
+        cdm_config.allow_distinctive_identifier =
+            (accumulated_configuration.distinctiveIdentifier ==
+             blink::WebMediaKeySystemConfiguration::Requirement::Required);
+        cdm_config.allow_persistent_state =
+            (accumulated_configuration.persistentState ==
+             blink::WebMediaKeySystemConfiguration::Requirement::Required);
+        cdm_config.use_secure_codecs = config_state.AreSecureCodecsRequired();
+        request->succeeded_cb.Run(accumulated_configuration, cdm_config);
         return;
     }
   }
 
   // 7.4. Reject promise with a new DOMException whose name is
   //      NotSupportedError.
   request->not_supported_cb.Run(
       "None of the requested configurations were supported.");
 }
 
 void KeySystemConfigSelector::OnPermissionResult(
     scoped_ptr<SelectionRequest> request,
     bool is_permission_granted) {
   request->was_permission_requested = true;
   request->is_permission_granted = is_permission_granted;
   SelectConfigInternal(request.Pass());
 }
 
 }  // namespace media