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 460 matching lines @@
  private:
   PpbBuffer* buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFramesImpl);
 };
 
 // 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::HostFactory,
                    public cdm::Host {
  public:
   CdmWrapper(PP_Instance instance, pp::Module* module);
   virtual ~CdmWrapper();
 
   // pp::Instance implementation.
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
@@ skipping 18 matching lines @@
       pp::Buffer_Dev extra_data_buffer) OVERRIDE;
   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;
 
+  // GetCdmHost implementation.

[ddorwin, 2013/02/07 23:50:21]

HostFactory

[xhwang, 2013/02/08 01:23:12]

Done.

+  virtual void* GetCdmHost(const char* host_version) OVERRIDE;
+
   // cdm::Host implementation.
   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;
   };
@@ skipping 312 matching lines @@
           encrypted_block_info.tracking_info));
       return;
     }
 
     default:
       PP_NOTREACHED();
       return;
   }
 }
 
+void* CdmWrapper::GetCdmHost(const char* host_version) {
+  if (strcmp(host_version, CDM_HOST_INTERFACE) == 0)
+    return static_cast<cdm::Host*>(this);
+  return NULL;
+}
+
 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 217 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