Update Pepper interface for EME

media/cdm/ppapi/cdm_adapter.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 "media/cdm/ppapi/cdm_adapter.h"
 
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
 #include "media/cdm/ppapi/supported_cdm_versions.h"
@@ skipping 305 matching lines @@
   }
 #endif  // defined(CHECK_DOCUMENT_URL)
 
   if (!cdm_ && !CreateCdmInstance(key_system))
     return;
 
   PP_DCHECK(cdm_);
   key_system_ = key_system;
 }
 
+void CdmAdapter::SetServerCertificate(uint32_t promise_id,
+                                      pp::VarArrayBuffer server_certificate) {
+  const uint8_t* server_certificate_ptr =
+      static_cast<const uint8_t*>(server_certificate.Map());
+  const uint32_t server_certificate_size = server_certificate.ByteLength();
+
+  PP_DCHECK(server_certificate_ptr);
+  PP_DCHECK(server_certificate_size > 0);
+
+  // Initialize() doesn't report an error, so SetServerCertificate() can be
+  // called even if Initialize() failed.

[ddorwin, 2014/08/22 20:49:20]

Is this true? This function can only be called by unprefixed on a valid
MediaKeys object, so this should never happen, right?

[jrummell, 2014/08/25 21:54:36]

Initialize() is called from PpapiDecryptor constructor, so once MediaKeys adds
SetServerCertificate(), I think it would be possible for this to happen.

+  // TODO(jrummell): Remove this code when prefixed EME gets removed.
+  if (!cdm_) {
+    RejectPromise(promise_id,
+                  cdm::kInvalidStateError,
+                  0,
+                  "CDM has not been initialized.");
+    return;
+  }
+
+  if (!cdm_->SetServerCertificate(
+          promise_id, server_certificate_ptr, server_certificate_size)) {
+    // CDM_4 and CDM_5 don't support this method, so reject the promise.
+    RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
+  }
+}
+
 void CdmAdapter::CreateSession(uint32_t promise_id,
                                const std::string& init_data_type,
                                pp::VarArrayBuffer init_data,
                                PP_SessionType session_type) {
   // Initialize() doesn't report an error, so CreateSession() can be called
   // even if Initialize() failed.
   // TODO(jrummell): Remove this code when prefixed EME gets removed.
   // TODO(jrummell): Verify that Initialize() failing does not resolve the
   // MediaKeys.create() promise.
   if (!cdm_) {
@@ skipping 40 matching lines @@
   PP_DCHECK(response_ptr);
   PP_DCHECK(response_size > 0);
 
   cdm_->UpdateSession(promise_id,
                       web_session_id.data(),
                       web_session_id.length(),
                       response_ptr,
                       response_size);
 }
 
-void CdmAdapter::ReleaseSession(uint32_t promise_id,
-                                const std::string& web_session_id) {
+void CdmAdapter::GetUsableKeyIds(uint32_t promise_id,

[ddorwin, 2014/08/22 20:49:20]

Why did this move?

[jrummell, 2014/08/25 21:54:36]

To line up with the order in the .h file. Moved back.

+                                 const std::string& web_session_id) {
+  if (!cdm_->GetUsableKeyIds(
+          promise_id, web_session_id.data(), web_session_id.length())) {
+    // CDM_4 and CDM_5 don't support this method, so reject the promise.
+    RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
+  }
+}
+
+void CdmAdapter::CloseSession(uint32_t promise_id,
+                              const std::string& web_session_id) {
   cdm_->CloseSession(
       promise_id, web_session_id.data(), web_session_id.length());
 }
 
 void CdmAdapter::RemoveSession(uint32_t promise_id,
                                const std::string& web_session_id) {
   if (!cdm_->RemoveSession(
           promise_id, web_session_id.data(), web_session_id.length())) {
     // CDM_4 and CDM_5 don't support this method, so reject the promise.
     RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
   }
 }
 
-void CdmAdapter::GetUsableKeyIds(uint32_t promise_id,
-                                 const std::string& web_session_id) {
-  if (!cdm_->GetUsableKeyIds(
-          promise_id, web_session_id.data(), web_session_id.length())) {
-    // CDM_4 and CDM_5 don't support this method, so reject the promise.
-    RejectPromise(promise_id, cdm::kNotSupportedError, 0, "Not implemented.");
-  }
-}
-
 // Note: In the following decryption/decoding related functions, errors are NOT
 // reported via KeyError, but are reported via corresponding PPB calls.
 
 void CdmAdapter::Decrypt(pp::Buffer_Dev encrypted_buffer,
                          const PP_EncryptedBlockInfo& encrypted_block_info) {
   PP_DCHECK(!encrypted_buffer.is_null());
 
   // Release a buffer that the caller indicated it is finished with.
   allocator_.Release(encrypted_block_info.tracking_info.buffer_id);
 
@@ skipping 418 matching lines @@
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseResolvedWithSession(promise_id,
                                                            web_session_id);
 }
 
 void CdmAdapter::SendPromiseResolvedWithUsableKeyIdsInternal(
     int32_t result,
     uint32_t promise_id,
     std::vector<std::vector<uint8> > key_ids) {
   PP_DCHECK(result == PP_OK);
-  // TODO(jrummell): Implement this event in subsequent CL.
-  // (http://crbug.com/358271).
+  pp::ContentDecryptor_Private::PromiseResolvedWithKeyIds(promise_id, key_ids);
 }
 
 void CdmAdapter::SendPromiseRejectedInternal(int32_t result,
                                              uint32_t promise_id,
                                              const SessionError& error) {
   PP_DCHECK(result == PP_OK);
   pp::ContentDecryptor_Private::PromiseRejected(
       promise_id,
       CdmExceptionTypeToPpCdmExceptionType(error.error),
       error.system_code,
@@ skipping 37 matching lines @@
       CdmExceptionTypeToPpCdmExceptionType(error.error),
       error.system_code,
       error.error_description);
 }
 
 void CdmAdapter::SendSessionUsableKeysChangeInternal(
     int32_t result,
     const std::string& web_session_id,
     bool has_additional_usable_key) {
   PP_DCHECK(result == PP_OK);
-  // TODO(jrummell): Implement this event in subsequent CL.
-  // (http://crbug.com/358271).
+  pp::ContentDecryptor_Private::SessionKeysChange(web_session_id,
+                                                  has_additional_usable_key);
 }
 
 void CdmAdapter::SendExpirationChangeInternal(int32_t result,
                                               const std::string& web_session_id,
                                               cdm::Time new_expiry_time) {
   PP_DCHECK(result == PP_OK);
-  // TODO(jrummell): Implement this event in subsequent CL.
-  // (http://crbug.com/358271).
+  pp::ContentDecryptor_Private::SessionExpirationChange(web_session_id,
+                                                        new_expiry_time);
 }
 
 void CdmAdapter::DeliverBlock(int32_t result,
                               const cdm::Status& status,
                               const LinkedDecryptedBlock& decrypted_block,
                               const PP_DecryptTrackingInfo& tracking_info) {
   PP_DCHECK(result == PP_OK);
   PP_DecryptedBlockInfo decrypted_block_info = {};
   decrypted_block_info.tracking_info = tracking_info;
   decrypted_block_info.tracking_info.timestamp = decrypted_block->Timestamp();
@@ skipping 430 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp