Ensure keymessage response to generateKeyRequest() has keySystem set for external CDMs.

webkit/media/crypto/ppapi/cdm_wrapper.cc

 // Copyright (c) 2012 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 16 matching lines @@
 #include "ppapi/utility/completion_callback_factory.h"
 #include "webkit/media/crypto/ppapi/content_decryption_module.h"
 #include "webkit/media/crypto/ppapi/linked_ptr.h"
 
 namespace {
 
 bool IsMainThread() {
   return pp::Module::Get()->core()->IsMainThread();
 }
 
+// Posts a task to run |cb| on the main thread. The task is posted even if the
+// current thread is the main thread.
+void PostOnMain(pp::CompletionCallback cb) {
+  pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
+}
+
+// Ensures |cb| is called on the main thread, either because the current thread
+// is the main thread or by posting it to the main thread.
 void CallOnMain(pp::CompletionCallback cb) {
   // TODO(tomfinegan): This is only necessary because PPAPI doesn't allow calls
   // off the main thread yet. Remove this once the change lands.
   if (IsMainThread())
     cb.Run(PP_OK);
   else
-    pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
+    PostOnMain(cb);
 }
 
 // Configures a cdm::InputBuffer. |subsamples| must exist as long as
 // |input_buffer| is in use.
 void ConfigureInputBuffer(
     const pp::Buffer_Dev& encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info,
     std::vector<cdm::SubsampleEntry>* subsamples,
     cdm::InputBuffer* input_buffer) {
   PP_DCHECK(subsamples);
@@ skipping 457 matching lines @@
   virtual void SendKeyError(const char* session_id,
                             int32_t session_id_length,
                             cdm::MediaKeyError error_code,
                             uint32_t system_code) OVERRIDE;
 
  private:
   typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
   typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
   typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;
 
+  void SendUnknownKeyError(const std::string& session_id);
+
+  void SendKeyAdded(const std::string& session_id);
+
   // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
   // <code>callback_factory_</code> to ensure that calls into
   // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
   void KeyAdded(int32_t result, const std::string& session_id);
   void KeyMessage(int32_t result,
                   const std::string& session_id,
                   const std::string& message,
                   const std::string& default_url);
   void KeyError(int32_t result,
                 const std::string& session_id,
@@ skipping 15 matching lines @@
                         uint32_t request_id);
   void DeliverFrame(int32_t result,
                     const cdm::Status& status,
                     const LinkedVideoFrame& video_frame,
                     const PP_DecryptTrackingInfo& tracking_info);
   void DeliverSamples(int32_t result,
                       const cdm::Status& status,
                       const LinkedAudioFrames& audio_frames,
                       const PP_DecryptTrackingInfo& tracking_info);
 
-  // Helper function to fire KeyError event on the main thread.
-  void SendUnknownKeyError(const std::string& session_id);
-
   // Helper for SetTimer().
   void TimerExpired(int32_t result, void* context);
 
   bool IsValidVideoFrame(const LinkedVideoFrame& video_frame);
 
   PpbBufferAllocator allocator_;
   pp::CompletionCallbackFactory<CdmWrapper> callback_factory_;
   cdm::ContentDecryptionModule* cdm_;
   std::string key_system_;
 
@@ skipping 60 matching lines @@
 
   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(session_id);
     return;
   }
 
-  CallOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyAdded, session_id));
+  SendKeyAdded(session_id);
 }
 
 void CdmWrapper::CancelKeyRequest(const std::string& session_id) {
   PP_DCHECK(cdm_);  // GenerateKeyRequest() should have succeeded.
   if (!cdm_) {
     SendUnknownKeyError(session_id);
     return;
   }
 
   cdm::Status status = cdm_->CancelKeyRequest(session_id.data(),
@@ skipping 163 matching lines @@
           encrypted_block_info.tracking_info));
       return;
     }
 
     default:
       PP_NOTREACHED();
       return;
   }
 }
 
-void CdmWrapper::SendUnknownKeyError(const std::string& session_id) {
-  CallOnMain(callback_factory_.NewCallback(
-      &CdmWrapper::KeyError, session_id, cdm::kUnknownError, 0));
-}
-
 void CdmWrapper::SetTimer(int64_t delay_ms, void* context) {
   // NOTE: doesn't really need to run on the main thread; could just as well run
   // on a helper thread if |cdm_| were thread-friendly and care was taken.  We
   // only use CallOnMainThread() here to get delayed-execution behavior.
   pp::Module::Get()->core()->CallOnMainThread(
       delay_ms,
       callback_factory_.NewCallback(&CdmWrapper::TimerExpired, context),
       PP_OK);
 }
 
 void CdmWrapper::TimerExpired(int32_t result, void* context) {
   PP_DCHECK(result == PP_OK);
   cdm_->TimerExpired(context);
 }
 
 double CdmWrapper::GetCurrentWallTimeInSeconds() {
   return pp::Module::Get()->core()->GetTime();
 }
 
 void CdmWrapper::SendKeyMessage(
     const char* session_id, int32_t session_id_length,
     const char* message, int32_t message_length,
     const char* default_url, int32_t default_url_length) {
-  CallOnMain(callback_factory_.NewCallback(
+  PostOnMain(callback_factory_.NewCallback(
       &CdmWrapper::KeyMessage,
       std::string(session_id, session_id_length),
       std::string(message, message_length),
       std::string(default_url, default_url_length)));
 }
 
 void CdmWrapper::SendKeyError(const char* session_id,
                               int32_t session_id_length,
                               cdm::MediaKeyError error_code,
                               uint32_t system_code) {
-  CallOnMain(callback_factory_.NewCallback(
+  PostOnMain(callback_factory_.NewCallback(
       &CdmWrapper::KeyError,
       std::string(session_id, session_id_length),
       error_code,
       system_code));
 }
 
+void CdmWrapper::SendUnknownKeyError(const std::string& session_id) {
+  SendKeyError(session_id.data(), session_id.size(), cdm::kUnknownError, 0);
+}
+
+void CdmWrapper::SendKeyAdded(const std::string& session_id) {
+  PostOnMain(callback_factory_.NewCallback(&CdmWrapper::KeyAdded,session_id));
+}
+
 void CdmWrapper::KeyAdded(int32_t result, const std::string& session_id) {
   PP_DCHECK(result == PP_OK);
+  PP_DCHECK(!key_system_.empty());
   pp::ContentDecryptor_Private::KeyAdded(key_system_, session_id);
 }
 
 void CdmWrapper::KeyMessage(int32_t result,
                             const std::string& session_id,
                             const std::string& message,
                             const std::string& default_url) {
   PP_DCHECK(result == PP_OK);
 
   pp::VarArrayBuffer message_array_buffer(message.size());
   if (message.size() > 0) {
     memcpy(message_array_buffer.Map(), message.data(), message.size());
   }
 
+  PP_DCHECK(!key_system_.empty());
   pp::ContentDecryptor_Private::KeyMessage(
       key_system_, session_id, message_array_buffer, default_url);
 }
 
-// TODO(xhwang): Support MediaKeyError (see spec: http://goo.gl/rbdnR) in CDM
-// interface and in this function.
 void CdmWrapper::KeyError(int32_t result,
                           const std::string& session_id,
                           cdm::MediaKeyError error_code,
                           uint32_t system_code) {
   PP_DCHECK(result == PP_OK);
+  PP_DCHECK(!key_system_.empty());
   pp::ContentDecryptor_Private::KeyError(
       key_system_, session_id, error_code, system_code);
 }
 
 void CdmWrapper::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;
@@ skipping 168 matching lines @@
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::CdmWrapperModule();
 }
 
 }  // namespace pp