Update Cdm Wrapper and ClearKeyCdm to work with CDM interface version 4.

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 237 matching lines @@
         size_(0) {}
   virtual ~PpbBuffer() {}
 
   pp::Buffer_Dev buffer_;
   uint32_t buffer_id_;
   int32_t size_;
 
   DISALLOW_COPY_AND_ASSIGN(PpbBuffer);
 };
 
-class PpbBufferAllocator : public cdm::Allocator {
+class PpbBufferAllocator {
  public:
   explicit PpbBufferAllocator(pp::Instance* instance)
       : instance_(instance),
         next_buffer_id_(1) {}
-  virtual ~PpbBufferAllocator() {}
+  ~PpbBufferAllocator() {}
 
-  // cdm::Allocator implementation.
-  virtual cdm::Buffer* Allocate(int32_t capacity) OVERRIDE;
+  cdm::Buffer* Allocate(int32_t capacity);
 
   // Releases the buffer with |buffer_id|. A buffer can be recycled after
   // it is released.
   void Release(uint32_t buffer_id);
 
  private:
   typedef std::map<uint32_t, pp::Buffer_Dev> AllocatedBufferMap;
   typedef std::multimap<int, std::pair<uint32_t, pp::Buffer_Dev> >
       FreeBufferMap;
 
@@ skipping 190 matching lines @@
   virtual cdm::Buffer* FrameBuffer() OVERRIDE {
     return buffer_;
   }
 
  private:
   PpbBuffer* buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFramesImpl);
 };
 
+// GetCdmHostFunc implementation.
+void* GetCdmHost(int host_interface_version, void* user_data);
+
 // A wrapper class for abstracting away PPAPI interaction and threading for a
 // Content Decryption Module (CDM).
 class CdmWrapper : public pp::Instance,
                    public pp::ContentDecryptor_Private,
                    public cdm::Host {
  public:
   CdmWrapper(PP_Instance instance, pp::Module* module);
   virtual ~CdmWrapper();
 
   // pp::Instance implementation.
@@ skipping 23 matching lines @@
   virtual void DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
                                    uint32_t request_id) OVERRIDE;
   virtual void ResetDecoder(PP_DecryptorStreamType decoder_type,
                             uint32_t request_id) OVERRIDE;
   virtual void DecryptAndDecode(
       PP_DecryptorStreamType decoder_type,
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
 
   // cdm::Host implementation.
+  virtual cdm::Buffer* Allocate(int32_t capacity) OVERRIDE;
   virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;
   virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
   virtual void 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) OVERRIDE;
   virtual void SendKeyError(const char* session_id,
                             int32_t session_id_length,
                             cdm::MediaKeyError error_code,
                             uint32_t system_code) OVERRIDE;
+  virtual void GetPrivateData(int32_t* instance,
+                              GetPrivateInterface* get_interface) OVERRIDE;
 
  private:
   struct SessionInfo {
     SessionInfo(const std::string& key_system_in,
                 const std::string& session_id_in)
         : key_system(key_system_in),
           session_id(session_id_in) {}
     const std::string key_system;
     const std::string session_id;
   };
 
   typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
   typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
   typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;
 
+  bool CreateCdmInstance(const std::string& key_system);
+
   void SendUnknownKeyError(const std::string& key_system,
                            const std::string& session_id);
 
   void SendKeyAdded(const std::string& key_system,
                     const std::string& session_id);
 
   void SendKeyErrorInternal(const std::string& key_system,
                             const std::string& session_id,
                             cdm::MediaKeyError error_code,
                             uint32_t system_code);
@@ skipping 49 matching lines @@
 CdmWrapper::CdmWrapper(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::ContentDecryptor_Private(this),
       allocator_(this),
       cdm_(NULL) {
   callback_factory_.Initialize(this);
 }
 
 CdmWrapper::~CdmWrapper() {
   if (cdm_)
-    DestroyCdmInstance(cdm_);
+    cdm_->Destroy();
+}
+
+bool CdmWrapper::CreateCdmInstance(const std::string& key_system) {
+  PP_DCHECK(!cdm_);
+  cdm_ = reinterpret_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,
                                     pp::VarArrayBuffer init_data) {
   PP_DCHECK(!key_system.empty());
   PP_DCHECK(key_system_.empty() || key_system_ == key_system);
 
   if (!cdm_) {
-    cdm_ = CreateCdmInstance(key_system.data(), key_system.size(),
-                             &allocator_, this);
-    PP_DCHECK(cdm_);
-    if (!cdm_) {
+    if (!CreateCdmInstance(key_system)) {
       SendUnknownKeyError(key_system, "");
       return;
     }
   }
+  PP_DCHECK(cdm_);
 
   // Must be set here in case the CDM synchronously calls a cdm::Host method.
   // Clear below on error.
-  // TODO(ddorwin): Remove this when key_system is added to cdm::Host methods.
+  // 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;
   }
@@ skipping 206 matching lines @@
           encrypted_block_info.tracking_info));
       return;
     }
 
     default:
       PP_NOTREACHED();
       return;
   }
 }
 
+cdm::Buffer* CdmWrapper::Allocate(int32_t capacity) {
+  return allocator_.Allocate(capacity);
+}
+
 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);
 }
 
@@ skipping 22 matching lines @@
 void CdmWrapper::SendKeyError(const char* session_id,
                               int32_t session_id_length,
                               cdm::MediaKeyError error_code,
                               uint32_t system_code) {
   SendKeyErrorInternal(key_system_,
                        std::string(session_id, session_id_length),
                        error_code,
                        system_code);
 }
 
+void CdmWrapper::GetPrivateData(int32_t* instance,
+                                cdm::Host::GetPrivateInterface* get_interface) {
+  *instance = pp_instance();
+  *get_interface = pp::Module::Get()->get_browser_interface();
+}
+
 void CdmWrapper::SendUnknownKeyError(const std::string& key_system,
                                      const std::string& session_id) {
   SendKeyErrorInternal(key_system, session_id, cdm::kUnknownError, 0);
 }
 
-
 void CdmWrapper::SendKeyAdded(const std::string& key_system,
                               const std::string& session_id) {
   PostOnMain(callback_factory_.NewCallback(
       &CdmWrapper::KeyAdded,
       SessionInfo(key_system_, session_id)));
 }
 
 void CdmWrapper::SendKeyErrorInternal(const std::string& key_system,
                                       const std::string& session_id,
                                       cdm::MediaKeyError error_code,
@@ skipping 189 matching lines @@
         static_cast<cdm::VideoFrame::VideoPlane>(i);
     if (ppb_buffer->Size() < video_frame->PlaneOffset(plane) +
                              plane_height * video_frame->Stride(plane)) {
       return false;
     }
   }
 
   return true;
 }
 
+void* GetCdmHost(int host_interface_version, void* user_data) {
+  if (!host_interface_version || !user_data)
+    return NULL;
+
+  if (host_interface_version != cdm::kHostInterfaceVersion)
+    return NULL;
+
+  CdmWrapper* cdm_wrapper = reinterpret_cast<CdmWrapper*>(user_data);
+  return static_cast<cdm::Host*>(cdm_wrapper);
+}
+
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class CdmWrapperModule : public pp::Module {
  public:
   CdmWrapperModule() : pp::Module() {
     // This function blocks the renderer thread (PluginInstance::Initialize()).
     // Move this call to other places if this may be a concern in the future.
     INITIALIZE_CDM_MODULE();
   }
   virtual ~CdmWrapperModule() {
     DeinitializeCdmModule();
   }
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new CdmWrapper(instance, this);
   }
 };
 
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::CdmWrapperModule();
 }
 
 }  // namespace pp