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"
+#include "webkit/media/crypto/ppapi/cdm_allocator.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);
 
   std::vector<media::SubsampleEntry> subsamples;
   for (uint32_t i = 0; i < input_buffer.num_subsamples; ++i) {
@@ skipping 94 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_iface_(NULL) {}
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
+bool ClearKeyCdm::Initialize(CdmAllocator* allocator) {

[ddorwin, 2012/09/04 09:53:15]

Is there a reason we can't do this in the constructor?

[Tom Finegan, 2012/09/07 00:46:36]

Nope, done. Also, I made the default constructor private. Not sure if that's OK
here, and, in the spirit of over engineering, added a NOTREACHED() to the
default constructor implementation.

+  if (!allocator) {

[ddorwin, 2012/09/04 09:53:15]

Seems like a DCHECK. And can remove return type (or add to constructor per
above).

[Tom Finegan, 2012/09/07 00:46:36]

Moved to constructor, and I put a DCHECK there.

+    return false;
+  }
+  allocator_iface_ = allocator;
+  return true;
+}
+
 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::kErrorUnknown;
 
   DCHECK(key_request);
   key_request->session_id = AllocateAndCopy(client_.session_id().data(),

[ddorwin, 2012/09/04 09:53:15]

These are still problematic. You can add a TODO for now if we want to get
Decrypt* tested and landed.
You may need to replace AllocateAndCopy() with the new code below and/or have
separate allocate functions for big and small values.

[Tom Finegan, 2012/09/07 00:46:36]

Added TODO for message. The other two are Vars-- maybe CdmAllocator needs
another design iteration that adds a type field, and support for Vars.

                                             client_.session_id().size());
   key_request->session_id_size = client_.session_id().size();
   key_request->message = AllocateAndCopy(client_.key_message(),
                                              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;
 }
@@ skipping 49 matching lines @@
                      base::Bind(&CopyDecryptResults, &status, &buffer));
 
   if (status == media::Decryptor::kError)
     return cdm::kErrorUnknown;
 
   if (status == media::Decryptor::kNoKey)
     return cdm::kErrorNoKey;
 
   DCHECK(buffer);
   int data_size = buffer->GetDataSize();
-  decrypted_buffer->data = AllocateAndCopy(buffer->GetData(), data_size);
-  decrypted_buffer->data_size = data_size;
+
+  decrypted_buffer->data =
+      allocator_iface_->Allocate(data_size,
+                                 &decrypted_buffer->buffer_id);
+  memcpy(reinterpret_cast<void*>(decrypted_buffer->data),

[ddorwin, 2012/09/04 09:53:15]

Copy = boo!
Maybe a TODO to make CopyDecoderBufferFrom take a target buffer so we can focus
on that separately.

[Tom Finegan, 2012/09/07 00:46:36]

TODO added.

+         buffer->GetData(),
+         data_size);
+
   decrypted_buffer->timestamp = buffer->GetTimestamp().InMicroseconds();
   return cdm::kSuccess;
 }
 
 }  // namespace webkit_media