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

webkit/media/crypto/ppapi/clear_key_cdm.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 "webkit/media/crypto/ppapi/clear_key_cdm.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
@@ skipping 107 matching lines @@
 void INITIALIZE_CDM_MODULE() {
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   DVLOG(2) << "FFmpeg libraries initialized: " << g_ffmpeg_lib_initialized;
   av_register_all();
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 void DeinitializeCdmModule() {
 }
 
-cdm::ContentDecryptionModule* CreateCdmInstance(const char* key_system_arg,
-                                                int key_system_size,
-                                                cdm::Allocator* allocator,
-                                                cdm::Host* host) {
+void* CreateCdmInstance(
+    int cdm_interface_version,
+    const char* key_system, int key_system_size,
+    GetCdmHostFunc get_cdm_host_func, void* user_data) {
   DVLOG(1) << "CreateCdmInstance()";
-  DCHECK_EQ(std::string(key_system_arg, key_system_size), kExternalClearKey);
-  return new webkit_media::ClearKeyCdm(allocator, host);
-}
 
-void DestroyCdmInstance(cdm::ContentDecryptionModule* instance) {
-  DVLOG(1) << "DestroyCdmInstance()";
-  delete instance;
+  if (cdm_interface_version != cdm::kCdmInterfaceVersion)
+    return NULL;
+
+  cdm::Host* host = reinterpret_cast<cdm::Host*>(
+      get_cdm_host_func(cdm::kHostInterfaceVersion, user_data));
+  if (!host)
+    return NULL;
+
+  return new webkit_media::ClearKeyCdm(host);
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace webkit_media {
 
 ClearKeyCdm::Client::Client() : status_(kKeyError) {}
 
@@ skipping 34 matching lines @@
                                   const std::string& session_id,
                                   const std::string& type,
                                   scoped_array<uint8> init_data,
                                   int init_data_length) {
   // In the current implementation of AesDecryptor, NeedKey is not used.
   // If no key is available to decrypt an input buffer, it returns kNoKey to
   // the caller instead of firing NeedKey.
   NOTREACHED();
 }
 
-ClearKeyCdm::ClearKeyCdm(cdm::Allocator* allocator, cdm::Host* host)
+ClearKeyCdm::ClearKeyCdm(cdm::Host* host)
     : decryptor_(base::Bind(&Client::KeyAdded, base::Unretained(&client_)),
                  base::Bind(&Client::KeyError, base::Unretained(&client_)),
                  base::Bind(&Client::KeyMessage, base::Unretained(&client_)),
                  base::Bind(&Client::NeedKey, base::Unretained(&client_))),
-      allocator_(allocator),
       host_(host),
       timer_delay_ms_(kInitialTimerDelayMs),
       timer_set_(false) {
-  DCHECK(allocator_);
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
   total_samples_generated_ = 0;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
@@ skipping 93 matching lines @@
   DCHECK(encrypted_buffer.data);
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
   DCHECK(buffer->GetData());
   decrypted_block->SetDecryptedBuffer(
-      allocator_->Allocate(buffer->GetDataSize()));
+      host_->Allocate(buffer->GetDataSize()));
   memcpy(reinterpret_cast<void*>(decrypted_block->DecryptedBuffer()->Data()),
          buffer->GetData(),
          buffer->GetDataSize());
   decrypted_block->DecryptedBuffer()->SetSize(buffer->GetDataSize());
   decrypted_block->SetTimestamp(buffer->GetTimestamp().InMicroseconds());
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::InitializeAudioDecoder(
     const cdm::AudioDecoderConfig& audio_decoder_config) {
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   if (!audio_decoder_)
-    audio_decoder_.reset(new webkit_media::FFmpegCdmAudioDecoder(allocator_));
+    audio_decoder_.reset(new webkit_media::FFmpegCdmAudioDecoder(host_));
 
   if (!audio_decoder_->Initialize(audio_decoder_config))
     return cdm::kSessionError;
 
   return cdm::kSuccess;
 #elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = audio_decoder_config.channel_count;
   bits_per_channel_ = audio_decoder_config.bits_per_channel;
   samples_per_second_ = audio_decoder_config.samples_per_second;
   return cdm::kSuccess;
 #else
   NOTIMPLEMENTED();
   return cdm::kSessionError;
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 cdm::Status ClearKeyCdm::InitializeVideoDecoder(
     const cdm::VideoDecoderConfig& video_decoder_config) {
   if (video_decoder_ && video_decoder_->is_initialized()) {
     DCHECK(!video_decoder_->is_initialized());
     return cdm::kSessionError;
   }
 
   // Any uninitialized decoder will be replaced.
-  video_decoder_ = CreateVideoDecoder(allocator_, video_decoder_config);
+  video_decoder_ = CreateVideoDecoder(host_, video_decoder_config);
   if (!video_decoder_)
     return cdm::kSessionError;
 
   return cdm::kSuccess;
 }
 
 void ClearKeyCdm::ResetDecoder(cdm::StreamType decoder_type) {
   DVLOG(1) << "ResetDecoder()";
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   switch (decoder_type) {
@@ skipping 76 matching lines @@
   if (!buffer->IsEndOfStream()) {
     timestamp_in_microseconds = buffer->GetTimestamp().InMicroseconds();
     DCHECK(timestamp_in_microseconds != kNoTimestamp);
   }
   return GenerateFakeAudioFrames(timestamp_in_microseconds, audio_frames);
 #else
   return cdm::kSuccess;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
+void ClearKeyCdm::Destroy() {
+  DVLOG(1) << "Destroy()";
+  delete this;
+}
+
 void ClearKeyCdm::ScheduleNextHeartBeat() {
   // Prepare the next heartbeat message and set timer.
   std::ostringstream msg_stream;
   msg_stream << kHeartBeatHeader << " from ClearKey CDM set at time "
              << host_->GetCurrentWallTimeInSeconds() << ".";
   next_heartbeat_message_ = msg_stream.str();
 
   host_->SetTimer(timer_delay_ms_, &next_heartbeat_message_[0]);
 
   // Use a smaller timer delay at start-up to facilitate testing. Increase the
@@ skipping 48 matching lines @@
   if (samples_to_generate <= 0)
     return 0;
 
   int64 bytes_per_sample = channel_count_ * bits_per_channel_ / 8;
   // |frame_size| must be a multiple of |bytes_per_sample|.
   int64 frame_size = bytes_per_sample * samples_to_generate;
 
   int64 timestamp = CurrentTimeStampInMicroseconds();
 
   const int kHeaderSize = sizeof(timestamp) + sizeof(frame_size);
-  audio_frames->SetFrameBuffer(allocator_->Allocate(kHeaderSize + frame_size));
+  audio_frames->SetFrameBuffer(host_->Allocate(kHeaderSize + frame_size));
   uint8_t* data = audio_frames->FrameBuffer()->Data();
 
   memcpy(data, &timestamp, sizeof(timestamp));
   data += sizeof(timestamp);
   memcpy(data, &frame_size, sizeof(frame_size));
   data += sizeof(frame_size);
   // You won't hear anything because we have all zeros here. But the video
   // should play just fine!
   memset(data, 0, frame_size);
 
@@ skipping 17 matching lines @@
   int samples_generated = GenerateFakeAudioFramesFromDuration(
       timestamp_in_microseconds - CurrentTimeStampInMicroseconds(),
       audio_frames);
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 }  // namespace webkit_media