Add CDM allocator interface.

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 <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "media/base/decoder_buffer.h"
 
 static const char kClearKeyCdmVersion[] = "0.1.0.0";
 
 static scoped_refptr<media::DecoderBuffer> CopyDecoderBufferFrom(
     const cdm::InputBuffer& input_buffer) {
   scoped_refptr<media::DecoderBuffer> output_buffer =
       media::DecoderBuffer::CopyFrom(input_buffer.data, input_buffer.data_size);

[ddorwin, 2012/09/07 09:48:48]

We'll want to avoid this copy too. Should .data be a CdmBuffer? (I'm more
worried about the interface and how it's used in the production CDM than I am
about this specific code (which just needs a TODO).

[Tom Finegan, 2012/09/08 01:02:47]

Done, added TODO.

 
   std::vector<media::SubsampleEntry> subsamples;
-  for (uint32_t i = 0; i < input_buffer.num_subsamples; ++i) {
+  for (int32_t i = 0; i < input_buffer.num_subsamples; ++i) {
     media::SubsampleEntry subsample;
     subsample.clear_bytes = input_buffer.subsamples[i].clear_bytes;
     subsample.cypher_bytes = input_buffer.subsamples[i].cipher_bytes;
     subsamples.push_back(subsample);
   }
 
   scoped_ptr<media::DecryptConfig> decrypt_config(new media::DecryptConfig(
       std::string(reinterpret_cast<const char*>(input_buffer.key_id),
                   input_buffer.key_id_size),
       std::string(reinterpret_cast<const char*>(input_buffer.iv),
@@ skipping 23 matching lines @@
 };
 
 template<typename Type>
 static Type* AllocateAndCopy(const Type* data, int size) {
   COMPILE_ASSERT(sizeof(Type) == 1, type_size_is_not_one);
   Type* copy = new Type[size];
   memcpy(copy, data, size);
   return copy;
 }
 
-cdm::ContentDecryptionModule* CreateCdmInstance() {
-  return new webkit_media::ClearKeyCdm();
+cdm::ContentDecryptionModule* CreateCdmInstance(cdm::CdmAllocator* allocator) {
+  return new webkit_media::ClearKeyCdm(allocator);
 }
 
 void DestroyCdmInstance(cdm::ContentDecryptionModule* instance) {
   delete instance;
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
@@ skipping 39 matching lines @@
 void ClearKeyCdm::Client::NeedKey(const std::string& key_system,
                                   const std::string& session_id,
                                   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() : decryptor_(&client_) {}
+ClearKeyCdm::ClearKeyCdm() : decryptor_(&client_), allocator_(NULL) {
+  NOTREACHED();

[ddorwin, 2012/09/07 09:48:48]

Why does this constructor exist? If you don't declare it, it won't exist because
you have the constructor below.

[Tom Finegan, 2012/09/08 01:02:47]

Removed.

+}
+
+ClearKeyCdm::ClearKeyCdm(cdm::CdmAllocator* allocator)
+    : decryptor_(&client_), allocator_(allocator) {
+  DCHECK(allocator_);
+}
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
 cdm::Status ClearKeyCdm::GenerateKeyRequest(const uint8_t* init_data,
                                             int init_data_size,
                                             cdm::KeyMessage* key_request) {
   DVLOG(1) << "GenerateKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
   decryptor_.GenerateKeyRequest("", init_data, init_data_size);
 
   if (client_.status() != Client::kKeyMessage)
     return cdm::kError;
 
   DCHECK(key_request);
   key_request->session_id = AllocateAndCopy(client_.session_id().data(),
                                             client_.session_id().size());
   key_request->session_id_size = client_.session_id().size();
+
+  // TODO(tomfinegan): Replace this |AllocateAndCopy()|. |message| should be
+  // a CdmBuffer, not a raw pointer.
   key_request->message = AllocateAndCopy(client_.key_message(),
-                                             client_.key_message_length());
+                                         client_.key_message_length());
   key_request->message_size = client_.key_message_length();
+
   key_request->default_url = AllocateAndCopy(client_.default_url().data(),
                                              client_.default_url().size());
   key_request->default_url_size = client_.default_url().size();
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::AddKey(const char* session_id,
                                 int session_id_size,
                                 const uint8_t* key,
                                 int key_size,
@@ skipping 44 matching lines @@
                      base::Bind(&CopyDecryptResults, &status, &buffer));
 
   if (status == media::Decryptor::kError)
     return cdm::kError;
 
   if (status == media::Decryptor::kNoKey)
     return cdm::kNoKey;
 
   DCHECK(buffer);
   int data_size = buffer->GetDataSize();
-  decrypted_buffer->data = AllocateAndCopy(buffer->GetData(), data_size);
-  decrypted_buffer->data_size = data_size;
+
+  const cdm::CdmBuffer& cdm_buffer = allocator_->Allocate(data_size);
+  DCHECK(cdm_buffer.buffer());

[ddorwin, 2012/09/07 09:48:48]

This can fail, so you should check and return an error.

[Tom Finegan, 2012/09/08 01:02:47]

Done-- also removed the DCHECKs, since they seem like overkill now that an error
is returned.

+  DCHECK_EQ(data_size, cdm_buffer.size());
+  decrypted_buffer->buffer_id = cdm_buffer.id();

[ddorwin, 2012/09/07 09:48:48]

After addressing comment in CDM.h, just copy the CdmBuffer here

[Tom Finegan, 2012/09/08 01:02:47]

Done, but it's just a pointer assignment.

+  decrypted_buffer->data = cdm_buffer.buffer();
+
+  // TODO(tomfinegan): Write a CopyDecoderBufferFrom that has a target buffer

[ddorwin, 2012/09/07 09:48:48]

I don't understand this comment. What you really need is the ability for
DecoderBuffer to wrap a CdmBuffer.

[Tom Finegan, 2012/09/08 01:02:47]

Fixed TODO.

+  // argument, and get rid of this memcpy.
+  memcpy(reinterpret_cast<void*>(decrypted_buffer->data),
+         buffer->GetData(),
+         data_size);
+
   decrypted_buffer->timestamp = buffer->GetTimestamp().InMicroseconds();
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::InitializeVideoDecoder(
     const cdm::VideoDecoderConfig& video_decoder_config) {
   NOTIMPLEMENTED();
   return cdm::kError;
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeVideo(
     const cdm::InputBuffer& encrypted_buffer,
     cdm::VideoFrame* video_frame) {
   NOTIMPLEMENTED();
   return cdm::kError;
 }
 
 void ClearKeyCdm::ResetVideoDecoder() {
   NOTIMPLEMENTED();
 }
 
 void ClearKeyCdm::StopVideoDecoder() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace webkit_media