Encrypted Media: Fix PpbBuffer::Destroy().

media/cdm/ppapi/cdm_adapter.cc

 // Copyright 2013 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/ppapi/cdm_adapter.h"
 
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
 #include "media/cdm/ppapi/supported_cdm_versions.h"
@@ skipping 837 matching lines @@
   pp::Buffer_Dev buffer;
 
   if (decrypted_block_info.result == PP_DECRYPTRESULT_SUCCESS) {
     PP_DCHECK(decrypted_block.get() && decrypted_block->DecryptedBuffer());
     if (!decrypted_block.get() || !decrypted_block->DecryptedBuffer()) {
       PP_NOTREACHED();
       decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
     } else {
       PpbBuffer* ppb_buffer =
           static_cast<PpbBuffer*>(decrypted_block->DecryptedBuffer());
-      buffer = ppb_buffer->buffer_dev();
       decrypted_block_info.tracking_info.buffer_id = ppb_buffer->buffer_id();
       decrypted_block_info.data_size = ppb_buffer->Size();
+      buffer = ppb_buffer->TakeBufferDev();

[xhwang, 2014/07/10 16:42:39]

This call also clears buffer_id and size. That's why I move it here. I thought
about some other names but still feel this is the best. Naming suggestions
welcome!

[ddorwin, 2014/07/10 21:56:14]

We never fixed the original naming. PpbBuffer isn't actually a PPB_Buffer_Dev.
*sigh*

I have no suggestions for that or this at the moment. We could probably drop the
"Dev" part of this new function name. Maybe it is differentiating the two
"buffers", but that's a crutch and we should solve the real problem. Maybe we
don't need to differentiate them, though. This is basically a deep move, leaving
the wrapper "empty".

[xhwang, 2014/07/10 22:37:33]

How about just BufferImpl, which is consistent with VideoFrameImpl.
 
Ok, I'll use TakeBuffer().

[ddorwin, 2014/07/10 22:43:24]

BufferImpl sounds good. In a different CL, of course.

[xhwang, 2014/07/10 22:48:50]

Will do.

     }
   }
 
   pp::ContentDecryptor_Private::DeliverBlock(buffer, decrypted_block_info);
 }
 
 void CdmAdapter::DecoderInitializeDone(int32_t result,
                                        PP_DecryptorStreamType decoder_type,
                                        uint32_t request_id,
                                        bool success) {
@@ skipping 30 matching lines @@
   pp::Buffer_Dev buffer;
 
   if (decrypted_frame_info.result == PP_DECRYPTRESULT_SUCCESS) {
     if (!IsValidVideoFrame(video_frame)) {
       PP_NOTREACHED();
       decrypted_frame_info.result = PP_DECRYPTRESULT_DECODE_ERROR;
     } else {
       PpbBuffer* ppb_buffer =
           static_cast<PpbBuffer*>(video_frame->FrameBuffer());
 
-      buffer = ppb_buffer->buffer_dev();
-
       decrypted_frame_info.tracking_info.timestamp = video_frame->Timestamp();
       decrypted_frame_info.tracking_info.buffer_id = ppb_buffer->buffer_id();
       decrypted_frame_info.format =
           CdmVideoFormatToPpDecryptedFrameFormat(video_frame->Format());
       decrypted_frame_info.width = video_frame->Size().width;
       decrypted_frame_info.height = video_frame->Size().height;
       decrypted_frame_info.plane_offsets[PP_DECRYPTEDFRAMEPLANES_Y] =
           video_frame->PlaneOffset(cdm::VideoFrame::kYPlane);
       decrypted_frame_info.plane_offsets[PP_DECRYPTEDFRAMEPLANES_U] =
           video_frame->PlaneOffset(cdm::VideoFrame::kUPlane);
       decrypted_frame_info.plane_offsets[PP_DECRYPTEDFRAMEPLANES_V] =
           video_frame->PlaneOffset(cdm::VideoFrame::kVPlane);
       decrypted_frame_info.strides[PP_DECRYPTEDFRAMEPLANES_Y] =
           video_frame->Stride(cdm::VideoFrame::kYPlane);
       decrypted_frame_info.strides[PP_DECRYPTEDFRAMEPLANES_U] =
           video_frame->Stride(cdm::VideoFrame::kUPlane);
       decrypted_frame_info.strides[PP_DECRYPTEDFRAMEPLANES_V] =
           video_frame->Stride(cdm::VideoFrame::kVPlane);
+
+      buffer = ppb_buffer->TakeBufferDev();
     }
   }
   pp::ContentDecryptor_Private::DeliverFrame(buffer, decrypted_frame_info);

[ddorwin, 2014/07/10 21:56:14]

nit: add an empty line for consistency (and because it's better IMO)

[xhwang, 2014/07/10 22:37:33]

Done.

 }
 
 void CdmAdapter::DeliverSamples(int32_t result,
                                 const cdm::Status& status,
                                 const LinkedAudioFrames& audio_frames,
                                 const PP_DecryptTrackingInfo& tracking_info) {
   PP_DCHECK(result == PP_OK);
 
   PP_DecryptedSampleInfo decrypted_sample_info;
   decrypted_sample_info.tracking_info = tracking_info;
   decrypted_sample_info.tracking_info.timestamp = 0;
   decrypted_sample_info.tracking_info.buffer_id = 0;
   decrypted_sample_info.data_size = 0;
   decrypted_sample_info.result = CdmStatusToPpDecryptResult(status);
 
   pp::Buffer_Dev buffer;
 
   if (decrypted_sample_info.result == PP_DECRYPTRESULT_SUCCESS) {
     PP_DCHECK(audio_frames.get() && audio_frames->FrameBuffer());
     if (!audio_frames.get() || !audio_frames->FrameBuffer()) {
       PP_NOTREACHED();
       decrypted_sample_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
     } else {
       PpbBuffer* ppb_buffer =
           static_cast<PpbBuffer*>(audio_frames->FrameBuffer());
-      buffer = ppb_buffer->buffer_dev();
+
       decrypted_sample_info.tracking_info.buffer_id = ppb_buffer->buffer_id();
       decrypted_sample_info.data_size = ppb_buffer->Size();
       decrypted_sample_info.format =
           CdmAudioFormatToPpDecryptedSampleFormat(audio_frames->Format());
+
+      buffer = ppb_buffer->TakeBufferDev();
     }
   }
 
   pp::ContentDecryptor_Private::DeliverSamples(buffer, decrypted_sample_info);
 }
 
 bool CdmAdapter::IsValidVideoFrame(const LinkedVideoFrame& video_frame) {
   if (!video_frame.get() ||
       !video_frame->FrameBuffer() ||
       (video_frame->Format() != cdm::kI420 &&
@@ skipping 287 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp