Use updated WebMediaKeySystemConfiguration

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/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/key_systems.h"
 #include "media/base/media_permission.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/blink/webcontentdecryptionmoduleaccess_impl.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaRequest.h"
 #include "third_party/WebKit/public/platform/WebMediaKeySystemConfiguration.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 namespace media {
 
 // These names are used by UMA.
 const char kKeySystemSupportUMAPrefix[] =
     "Media.EME.RequestMediaKeySystemAccess.";
 
-// TODO(jrummell): Convert to an enum. http://crbug.com/418239
-const char kTemporarySessionType[] = "temporary";
-const char kPersistentLicenseSessionType[] = "persistent-license";
-const char kPersistentReleaseMessageSessionType[] =
-    "persistent-release-message";
-
 enum ConfigurationSupport {
   CONFIGURATION_NOT_SUPPORTED,
   CONFIGURATION_REQUIRES_PERMISSION,
   CONFIGURATION_SUPPORTED,
 };
 
 static bool IsSupportedContentType(const std::string& key_system,
                                    const std::string& mime_type,
                                    const std::string& codecs) {
   // TODO(sandersd): Move contentType parsing from Blink to here so that invalid
@@ skipping 100 matching lines @@
 
   // It is possible to obtain user permission unless permission was already
   // requested and denied.
   bool is_permission_possible =
       !was_permission_requested || is_permission_granted;
 
   // From https://w3c.github.io/encrypted-media/#get-supported-configuration
   // 1. Let accumulated configuration be empty. (Done by caller.)
   // 2. If candidate configuration's initDataTypes attribute is not empty, run
   //    the following steps:
-  if (!candidate.initDataTypes.isEmpty()) {
+  blink::WebVector<blink::WebEncryptedMediaInitDataType> init_data_types =
+      candidate.getInitDataTypes();
+  if (!init_data_types.isEmpty()) {
     // 2.1. Let supported types be empty.
-    std::vector<blink::WebString> supported_types;
+    std::vector<blink::WebEncryptedMediaInitDataType> supported_types;
 
     // 2.2. For each value in candidate configuration's initDataTypes attribute:
-    for (size_t i = 0; i < candidate.initDataTypes.size(); i++) {
+    for (size_t i = 0; i < init_data_types.size(); i++) {
       // 2.2.1. Let initDataType be the value.
-      const blink::WebString& init_data_type = candidate.initDataTypes[i];
+      blink::WebEncryptedMediaInitDataType init_data_type = init_data_types[i];
       // 2.2.2. If initDataType is the empty string, return null.
-      if (init_data_type.isEmpty())
-        return CONFIGURATION_NOT_SUPPORTED;
+      if (init_data_type == blink::WebEncryptedMediaInitDataType::Unknown)
+        continue;
       // 2.2.3. If the implementation supports generating requests based on
       //        initDataType, add initDataType to supported types. String
       //        comparison is case-sensitive.
-      if (base::IsStringASCII(init_data_type) &&
-          IsSupportedKeySystemWithInitDataType(
-              key_system, base::UTF16ToASCII(init_data_type))) {
+      // TODO(jrummell): |init_data_type| should be an enum all the way through
+      // Chromium. http://crbug.com/417440
+      std::string init_data_type_as_ascii = "unknown";
+      switch (init_data_type) {
+        case blink::WebEncryptedMediaInitDataType::Cenc:
+          init_data_type_as_ascii = "cenc";
+          break;
+        case blink::WebEncryptedMediaInitDataType::Keyids:
+          init_data_type_as_ascii = "keyids";
+          break;
+        case blink::WebEncryptedMediaInitDataType::Webm:
+          init_data_type_as_ascii = "webm";
+          break;
+        case blink::WebEncryptedMediaInitDataType::Unknown:
+          NOTREACHED();
+          break;
+      }
+      if (IsSupportedKeySystemWithInitDataType(key_system,
+                                               init_data_type_as_ascii)) {
         supported_types.push_back(init_data_type);
       }
     }
 
     // 2.3. If supported types is empty, return null.
     if (supported_types.empty())
       return CONFIGURATION_NOT_SUPPORTED;
 
     // 2.4. Add supported types to accumulated configuration.
-    accumulated_configuration->initDataTypes = supported_types;
+    accumulated_configuration->setInitDataTypes(supported_types);
   }
 
   // 3. Follow the steps for the value of candidate configuration's
   //    distinctiveIdentifier attribute from the following list:
   //     - "required": If the implementation does not support a persistent
   //       Distinctive Identifier in combination with accumulated configuration,
   //       return null.
   //     - "optional": Continue.
   //     - "not-allowed": If the implementation requires a Distinctive
   //       Identifier in combination with accumulated configuration, return
@@ skipping 131 matching lines @@
       ConvertRequirement(accumulated_configuration->persistentState);
   if (!IsPersistentStateRequirementSupported(key_system, ps_requirement,
                                              is_permission_granted)) {
     DCHECK(!was_permission_requested);  // Should have failed at step 5.
     return CONFIGURATION_REQUIRES_PERMISSION;
   }
 
   // 12. Return accumulated configuration.
   //     (As an extra step, we record the available session types so that
   //     createSession() can be synchronous.)
-  std::vector<blink::WebString> session_types;
-  session_types.push_back(kTemporarySessionType);
+  std::vector<blink::WebEncryptedMediaSessionType> session_types;
+  session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
   if (accumulated_configuration->persistentState ==
       blink::WebMediaKeySystemConfiguration::Requirement::Required) {
     if (IsPersistentLicenseSessionSupported(key_system,
                                             is_permission_granted)) {
-      session_types.push_back(kPersistentLicenseSessionType);
+      session_types.push_back(
+          blink::WebEncryptedMediaSessionType::PersistentLicense);
     }
     if (IsPersistentReleaseMessageSessionSupported(key_system,
                                                    is_permission_granted)) {
-      session_types.push_back(kPersistentReleaseMessageSessionType);
+      session_types.push_back(
+          blink::WebEncryptedMediaSessionType::PersistentReleaseMessage);
     }
   }
-  accumulated_configuration->sessionTypes = session_types;
+  accumulated_configuration->setSessionTypes(session_types);
 
   return CONFIGURATION_SUPPORTED;
 }
 
 // Report usage of key system to UMA. There are 2 different counts logged:
 // 1. The key system is requested.
 // 2. The requested key system and options are supported.
 // Each stat is only reported once per renderer frame per key system.
 // Note that WebEncryptedMediaClientImpl is only created once by each
 // renderer frame.
@@ skipping 154 matching lines @@
     return reporter;
 
   // Reporter not found, so create one.
   auto result =
       reporters_.add(uma_name, make_scoped_ptr(new Reporter(uma_name)));
   DCHECK(result.second);
   return result.first->second;
 }
 
 }  // namespace media