Check InitDateType is supported by key system when creating session

media/blink/webcontentdecryptionmodulesession_impl.cc

 // Copyright 2013 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 "webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
+#include "media/base/key_systems.h"
 #include "media/base/media_keys.h"
 #include "media/blink/cdm_result_promise.h"
 #include "media/blink/cdm_session_adapter.h"
 #include "media/blink/new_session_cdm_result_promise.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaKeyInformation.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
@@ skipping 64 matching lines @@
 }
 
 blink::WebString WebContentDecryptionModuleSessionImpl::sessionId() const {
   return blink::WebString::fromUTF8(session_id_);
 }
 
 void WebContentDecryptionModuleSessionImpl::initializeNewSession(
     const blink::WebString& init_data_type,
     const uint8* init_data,
     size_t init_data_length) {
   // TODO(jrummell): Remove once blink updated.

[ddorwin, 2015/02/04 23:42:23]

Done? Ditto for two below.

[jrummell, 2015/02/05 01:01:28]

I was going to do some cleanups in a separate CL.

   NOTREACHED();
 }
 
 void WebContentDecryptionModuleSessionImpl::update(const uint8* response,
                                                    size_t response_length) {
   // TODO(jrummell): Remove once blink updated.
   NOTREACHED();
 }
 
 void WebContentDecryptionModuleSessionImpl::release() {
   // TODO(jrummell): Remove once blink updated.
   NOTREACHED();
 }
 
 void WebContentDecryptionModuleSessionImpl::initializeNewSession(
     const blink::WebString& init_data_type,
     const uint8* init_data,
     size_t init_data_length,
     const blink::WebString& session_type,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(session_id_.empty());
 
   // TODO(ddorwin): Guard against this in supported types check and remove this.
   // Chromium only supports ASCII MIME types.
   if (!base::IsStringASCII(init_data_type)) {
     NOTREACHED();

[ddorwin, 2015/02/04 23:42:23]

Do we have LTs that test non-ascii handling?

I think we will hit this when the isKeySystemSupportedWithInitDataType() call is
removed in Blink. Will we implement the check in Blink or should we just handle
it here? Ideally, we'd use enums for IDT (418239), which would address this
specific TODO..

[jrummell, 2015/02/05 01:01:28]

No LTs since we typically don't mess with InitDataType. But I can add some in
encrypted-media-syntax.html when I do the blink change.

[ddorwin, 2015/02/05 01:09:31]

SG, but what is the plan to avoid hitting the NOTREACHED()? I guess this CL is
fine, but you might need another Chromium CL before the Blink one.

[jrummell, 2015/02/05 20:42:14]

Where step 5 is on the blink side I may need to check that it is ASCII only.
I'll add a test case first and see if it hits this.

     std::string message = "The initialization data type " +
                           init_data_type.utf8() +
                           " is not supported by the key system.";
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionNotSupportedError, 0,
         blink::WebString::fromUTF8(message));
     return;
   }
 
   std::string init_data_type_as_ascii = base::UTF16ToASCII(init_data_type);
   DLOG_IF(WARNING, init_data_type_as_ascii.find('/') != std::string::npos)
       << "init_data_type '" << init_data_type_as_ascii
       << "' may be a MIME type";
 
+  // Step 5 from https://w3c.github.io/encrypted-media/#generateRequest.
+  // 5. If the Key System implementation represented by this object's cdm
+  //    implementation value does not support initDataType as an Initialization
+  //    Data Type, return a promise rejected with a new DOMException whose name
+  //    is NotSupportedError. String comparison is case-sensitive.
+  if (!IsSupportedKeySystemWithInitDataType(adapter_->GetKeySystem(),
+                                            init_data_type_as_ascii)) {
+    std::string message = "The initialization data type " +
+                          init_data_type_as_ascii +
+                          " is not supported by the key system.";
+    result.completeWithError(
+        blink::WebContentDecryptionModuleExceptionNotSupportedError, 0,
+        blink::WebString::fromUTF8(message));
+    return;
+  }
+
   MediaKeys::SessionType session_type_enum;
   if (session_type == kPersistentLicenseSessionType) {
     session_type_enum = MediaKeys::PERSISTENT_LICENSE_SESSION;
   } else if (session_type == kPersistentReleaseMessageSessionType) {
     session_type_enum = MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION;
   } else {
     DCHECK(session_type == kTemporarySessionType);
     session_type_enum = MediaKeys::TEMPORARY_SESSION;
   }
 
@@ skipping 106 matching lines @@
     return blink::WebContentDecryptionModuleResult::SessionNotFound;
 
   DCHECK(session_id_.empty()) << "Session ID may not be changed once set.";
   session_id_ = session_id;
   return adapter_->RegisterSession(session_id_, weak_ptr_factory_.GetWeakPtr())
              ? blink::WebContentDecryptionModuleResult::NewSession
              : blink::WebContentDecryptionModuleResult::SessionAlreadyExists;
 }
 
 }  // namespace media