Add allocator interface for use by cdm_adapter

media/cdm/cdm_adapter.cc

 // Copyright 2015 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 "media/cdm/cdm_adapter.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_initialized_promise.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/channel_layout.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/limits.h"
 #include "media/base/sample_format.h"
 #include "media/base/video_codecs.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_types.h"
-#include "media/cdm/cdm_buffer_impl.h"
+#include "media/cdm/cdm_allocator.h"
 #include "media/cdm/cdm_helpers.h"
 #include "media/cdm/cdm_wrapper.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace media {
 
 namespace {
 
 cdm::SessionType ToCdmSessionType(MediaKeys::SessionType session_type) {
   switch (session_type) {
@@ skipping 279 matching lines @@
   }
 }
 
 }  // namespace
 
 // static
 void CdmAdapter::Create(
     const std::string& key_system,
     const base::FilePath& cdm_path,
     const CdmConfig& cdm_config,
+    scoped_ptr<CdmAllocator> allocator,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb,
     const CdmCreatedCB& cdm_created_cb) {
   DCHECK(!key_system.empty());
   DCHECK(!session_message_cb.is_null());
   DCHECK(!session_closed_cb.is_null());
   DCHECK(!legacy_session_error_cb.is_null());
   DCHECK(!session_keys_change_cb.is_null());
   DCHECK(!session_expiration_update_cb.is_null());
 
-  scoped_refptr<CdmAdapter> cdm =
-      new CdmAdapter(key_system, cdm_config, session_message_cb,
-                     session_closed_cb, legacy_session_error_cb,
-                     session_keys_change_cb, session_expiration_update_cb);
+  scoped_refptr<CdmAdapter> cdm = new CdmAdapter(
+      key_system, cdm_config, std::move(allocator), session_message_cb,
+      session_closed_cb, legacy_session_error_cb, session_keys_change_cb,
+      session_expiration_update_cb);
 
   // |cdm| ownership passed to the promise.
   scoped_ptr<CdmInitializedPromise> cdm_created_promise(
       new CdmInitializedPromise(cdm_created_cb, cdm));
 
   cdm->Initialize(cdm_path, std::move(cdm_created_promise));
 }
 
 CdmAdapter::CdmAdapter(
     const std::string& key_system,
     const CdmConfig& cdm_config,
+    scoped_ptr<CdmAllocator> allocator,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb)
     : key_system_(key_system),
       cdm_config_(cdm_config),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       legacy_session_error_cb_(legacy_session_error_cb),
       session_keys_change_cb_(session_keys_change_cb),
       session_expiration_update_cb_(session_expiration_update_cb),
       audio_samples_per_second_(0),
       audio_channel_layout_(CHANNEL_LAYOUT_NONE),
+      allocator_(std::move(allocator)),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {
   DCHECK(!key_system_.empty());
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!legacy_session_error_cb_.is_null());
   DCHECK(!session_keys_change_cb_.is_null());
   DCHECK(!session_expiration_update_cb_.is_null());
+  DCHECK(allocator_);
 }
 
 CdmAdapter::~CdmAdapter() {}
 
 CdmWrapper* CdmAdapter::CreateCdmInstance(const std::string& key_system,
                                           const base::FilePath& cdm_path) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // TODO(jrummell): We need to call INITIALIZE_CDM_MODULE() and
   // DeinitializeCdmModule(). However, that should only be done once for the
@@ skipping 268 matching lines @@
 
 void CdmAdapter::DecryptAndDecodeVideo(
     const scoped_refptr<DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(3) << __FUNCTION__
            << " encrypted: " << encrypted->AsHumanReadableString();
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
-  scoped_ptr<VideoFrameImpl> video_frame(new VideoFrameImpl());
+  scoped_ptr<VideoFrameImpl> video_frame = allocator_->CreateCdmVideoFrame();
 
   ToCdmInputBuffer(encrypted, &subsamples, &input_buffer);
   cdm::Status status =
       cdm_->DecryptAndDecodeFrame(input_buffer, video_frame.get());
 
   if (status != cdm::kSuccess) {
     DVLOG(1) << __FUNCTION__ << " failed with cdm::Error " << status;
     video_decode_cb.Run(ToMediaDecryptorStatus(status), nullptr);
     return;
   }
 
-  uint8_t* frame_data = video_frame->FrameBuffer()->Data();
-  gfx::Size frame_size(video_frame->Size().width, video_frame->Size().height);
-  scoped_refptr<VideoFrame> decoded_frame = VideoFrame::WrapExternalYuvData(
-      PIXEL_FORMAT_YV12, frame_size, gfx::Rect(frame_size), natural_size_,
-      video_frame->Stride(VideoFrameImpl::kYPlane),
-      video_frame->Stride(VideoFrameImpl::kUPlane),
-      video_frame->Stride(VideoFrameImpl::kVPlane),
-      frame_data + video_frame->PlaneOffset(VideoFrameImpl::kYPlane),
-      frame_data + video_frame->PlaneOffset(VideoFrameImpl::kUPlane),
-      frame_data + video_frame->PlaneOffset(VideoFrameImpl::kVPlane),
-      base::TimeDelta::FromMicroseconds(video_frame->Timestamp()));
+  scoped_refptr<VideoFrame> decoded_frame =
+      video_frame->TransformToVideoFrame(natural_size_);
   video_decode_cb.Run(Decryptor::kSuccess, decoded_frame);
 }
 
 void CdmAdapter::ResetDecoder(StreamType stream_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   cdm_->ResetDecoder(ToCdmStreamType(stream_type));
 }
 
 void CdmAdapter::DeinitializeDecoder(StreamType stream_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   cdm_->DeinitializeDecoder(ToCdmStreamType(stream_type));
 
   // Reset the saved values from initializing the decoder.
   switch (stream_type) {
     case Decryptor::kAudio:
       audio_samples_per_second_ = 0;
       audio_channel_layout_ = CHANNEL_LAYOUT_NONE;
       break;
     case Decryptor::kVideo:
       natural_size_ = gfx::Size();
       break;
   }
 }
 
 cdm::Buffer* CdmAdapter::Allocate(uint32_t capacity) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  return CdmBuffer::Create(capacity);
+  return allocator_->CreateCdmBuffer(capacity);
 }
 
 void CdmAdapter::SetTimer(int64_t delay_ms, void* context) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&CdmAdapter::TimerExpired,
                                            weak_factory_.GetWeakPtr(), context),
                                 base::TimeDelta::FromMilliseconds(delay_ms));
 }
 
@@ skipping 225 matching lines @@
     result_frames->push_back(frame);
 
     data += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace media