Changes to the EME Pepper API

media/cdm/ppapi/cdm_wrapper.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 <cstring>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 480 matching lines @@
   virtual ~CdmWrapper();
 
   // pp::Instance implementation.
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
   // PPP_ContentDecryptor_Private implementation.
   // Note: Results of calls to these methods must be reported through the
   // PPB_ContentDecryptor_Private interface.
-  virtual void GenerateKeyRequest(const std::string& key_system,
-                                  const std::string& type,
+  virtual void Initialize(const std::string& key_system,
+                          bool can_challenge_platform) OVERRIDE;
+  virtual void GenerateKeyRequest(const std::string& type,
                                   pp::VarArrayBuffer init_data) OVERRIDE;
   virtual void AddKey(const std::string& session_id,
                       pp::VarArrayBuffer key,
                       pp::VarArrayBuffer init_data) OVERRIDE;
   virtual void CancelKeyRequest(const std::string& session_id) OVERRIDE;
   virtual void Decrypt(
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
   virtual void InitializeAudioDecoder(
       const PP_AudioDecoderConfig& decoder_config,
@@ skipping 116 matching lines @@
 bool CdmWrapper::CreateCdmInstance(const std::string& key_system) {
   PP_DCHECK(!cdm_);
   cdm_ = static_cast<cdm::ContentDecryptionModule*>(
       ::CreateCdmInstance(cdm::kCdmInterfaceVersion,
                           key_system.data(), key_system.size(),
                           GetCdmHost, this));
 
   return (cdm_ != NULL);
 }
 
-void CdmWrapper::GenerateKeyRequest(const std::string& key_system,
-                                    const std::string& type,
+void CdmWrapper::Initialize(const std::string& key_system,
+                            bool can_challenge_platform) {
+  PP_DCHECK(!key_system.empty());
+  PP_DCHECK(key_system_.empty() || (key_system_ == key_system && cdm_));
+
+  if (!cdm_) {
+    if (!CreateCdmInstance(key_system)) {
+      // TODO(jrummell): Is UnknownKeyError the correct response?
+      SendUnknownKeyError(key_system, std::string());
+      return;
+    }
+  }
+  PP_DCHECK(cdm_);
+  key_system_ = key_system;
+}
+
+void CdmWrapper::GenerateKeyRequest(const std::string& type,
                                     pp::VarArrayBuffer init_data) {
-  PP_DCHECK(!key_system.empty());
-  PP_DCHECK(key_system_.empty() || key_system_ == key_system);
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
 
 #if defined(CHECK_DOCUMENT_URL)
   PP_URLComponents_Dev url_components = {};
   pp::Var href = pp::URLUtil_Dev::Get()->GetDocumentURL(
       pp::InstanceHandle(pp_instance()), &url_components);
   PP_DCHECK(href.is_string());
   PP_DCHECK(!href.AsString().empty());
   PP_DCHECK(url_components.host.begin);
   PP_DCHECK(0 < url_components.host.len);
 #endif  // defined(CHECK_DOCUMENT_URL)
 
-  if (!cdm_) {
-    if (!CreateCdmInstance(key_system)) {
-      SendUnknownKeyError(key_system, std::string());
-      return;
-    }
-  }
-  PP_DCHECK(cdm_);
-
-  // Must be set here in case the CDM synchronously calls a cdm::Host method.
-  // Clear below on error.
-  // TODO(ddorwin): Set/clear key_system_ & cdm_ at same time; clear both on
-  // error below.
-  key_system_ = key_system;
   cdm::Status status = cdm_->GenerateKeyRequest(
       type.data(), type.size(),
       static_cast<const uint8_t*>(init_data.Map()),
       init_data.ByteLength());
   PP_DCHECK(status == cdm::kSuccess || status == cdm::kSessionError);
-  if (status != cdm::kSuccess) {
-    key_system_.clear();  // See comment above.
-    return;
-  }
-
-  key_system_ = key_system;
+  if (status != cdm::kSuccess)
+    SendUnknownKeyError(key_system_, std::string());
 }
 
 void CdmWrapper::AddKey(const std::string& session_id,
                         pp::VarArrayBuffer key,
                         pp::VarArrayBuffer init_data) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
   if (!cdm_) {
     SendUnknownKeyError(key_system_, session_id);
     return;
   }
 
   const uint8_t* key_ptr = static_cast<const uint8_t*>(key.Map());
   int key_size = key.ByteLength();
   const uint8_t* init_data_ptr = static_cast<const uint8_t*>(init_data.Map());
   int init_data_size = init_data.ByteLength();
   PP_DCHECK(!init_data_ptr == !init_data_size);
 
   if (!key_ptr || key_size <= 0) {
     SendUnknownKeyError(key_system_, session_id);
     return;
   }
 
   cdm::Status status = cdm_->AddKey(session_id.data(), session_id.size(),
                                     key_ptr, key_size,
                                     init_data_ptr, init_data_size);
   PP_DCHECK(status == cdm::kSuccess || status == cdm::kSessionError);
   if (status != cdm::kSuccess) {
     SendUnknownKeyError(key_system_, session_id);
     return;
   }
 
   SendKeyAdded(key_system_, session_id);
 }
 
 void CdmWrapper::CancelKeyRequest(const std::string& session_id) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
   if (!cdm_) {
     SendUnknownKeyError(key_system_, session_id);
     return;
   }
 
   cdm::Status status = cdm_->CancelKeyRequest(session_id.data(),
                                               session_id.size());
   PP_DCHECK(status == cdm::kSuccess || status == cdm::kSessionError);
   if (status != cdm::kSuccess)
     SendUnknownKeyError(key_system_, session_id);
 }
 
 // Note: In the following decryption/decoding related functions, errors are NOT
 // reported via KeyError, but are reported via corresponding PPB calls.
 
 void CdmWrapper::Decrypt(pp::Buffer_Dev encrypted_buffer,
                          const PP_EncryptedBlockInfo& encrypted_block_info) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
   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);
 
   cdm::Status status = cdm::kDecryptError;
   LinkedDecryptedBlock decrypted_block(new DecryptedBlockImpl());
 
   if (cdm_) {
     cdm::InputBuffer input_buffer;
     std::vector<cdm::SubsampleEntry> subsamples;
     ConfigureInputBuffer(encrypted_buffer, encrypted_block_info, &subsamples,
                          &input_buffer);
     status = cdm_->Decrypt(input_buffer, decrypted_block.get());
     PP_DCHECK(status != cdm::kSuccess ||
               (decrypted_block->DecryptedBuffer() &&
                decrypted_block->DecryptedBuffer()->Size()));
   }
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DeliverBlock,
       status,
       decrypted_block,
       encrypted_block_info.tracking_info));
 }
 
 void CdmWrapper::InitializeAudioDecoder(
     const PP_AudioDecoderConfig& decoder_config,
     pp::Buffer_Dev extra_data_buffer) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
 
   cdm::Status status = cdm::kSessionError;
   if (cdm_) {
     cdm::AudioDecoderConfig cdm_decoder_config;
     cdm_decoder_config.codec =
         PpAudioCodecToCdmAudioCodec(decoder_config.codec);
     cdm_decoder_config.channel_count = decoder_config.channel_count;
     cdm_decoder_config.bits_per_channel = decoder_config.bits_per_channel;
     cdm_decoder_config.samples_per_second = decoder_config.samples_per_second;
     cdm_decoder_config.extra_data =
         static_cast<uint8_t*>(extra_data_buffer.data());
     cdm_decoder_config.extra_data_size =
         static_cast<int32_t>(extra_data_buffer.size());
     status = cdm_->InitializeAudioDecoder(cdm_decoder_config);
   }
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DecoderInitializeDone,
       PP_DECRYPTORSTREAMTYPE_AUDIO,
       decoder_config.request_id,
       status == cdm::kSuccess));
 }
 
 void CdmWrapper::InitializeVideoDecoder(
     const PP_VideoDecoderConfig& decoder_config,
     pp::Buffer_Dev extra_data_buffer) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
 
   cdm::Status status = cdm::kSessionError;
   if (cdm_) {
     cdm::VideoDecoderConfig cdm_decoder_config;
     cdm_decoder_config.codec =
         PpVideoCodecToCdmVideoCodec(decoder_config.codec);
     cdm_decoder_config.profile =
         PpVCProfileToCdmVCProfile(decoder_config.profile);
     cdm_decoder_config.format =
         PpDecryptedFrameFormatToCdmVideoFormat(decoder_config.format);
     cdm_decoder_config.coded_size.width = decoder_config.width;
     cdm_decoder_config.coded_size.height = decoder_config.height;
     cdm_decoder_config.extra_data =
         static_cast<uint8_t*>(extra_data_buffer.data());
     cdm_decoder_config.extra_data_size =
         static_cast<int32_t>(extra_data_buffer.size());
     status = cdm_->InitializeVideoDecoder(cdm_decoder_config);
   }
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DecoderInitializeDone,
       PP_DECRYPTORSTREAMTYPE_VIDEO,
       decoder_config.request_id,
       status == cdm::kSuccess));
 }
 
 void CdmWrapper::DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
                                      uint32_t request_id) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
   if (cdm_) {
     cdm_->DeinitializeDecoder(
         PpDecryptorStreamTypeToCdmStreamType(decoder_type));
   }
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DecoderDeinitializeDone,
       decoder_type,
       request_id));
 }
 
 void CdmWrapper::ResetDecoder(PP_DecryptorStreamType decoder_type,
                               uint32_t request_id) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
   if (cdm_)
     cdm_->ResetDecoder(PpDecryptorStreamTypeToCdmStreamType(decoder_type));
 
   CallOnMain(callback_factory_.NewCallback(&CdmWrapper::DecoderResetDone,
                                            decoder_type,
                                            request_id));
 }
 
 void CdmWrapper::DecryptAndDecode(
     PP_DecryptorStreamType decoder_type,
     pp::Buffer_Dev encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info) {
-  PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
+  PP_DCHECK(cdm_);  // Initialize() should have succeeded.
 
   // Release a buffer that the caller indicated it is finished with.
   allocator_.Release(encrypted_block_info.tracking_info.buffer_id);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   if (cdm_ && !encrypted_buffer.is_null()) {
     ConfigureInputBuffer(encrypted_buffer,
                          encrypted_block_info,
                          &subsamples,
@@ skipping 333 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmWrapperModule();
 }
 
 }  // namespace pp