Reland "Update mojo Decryptor interface to support reusing shared memory"

media/mojo/services/mojo_decryptor.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/mojo/services/mojo_decryptor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/common/media_type_converters.h"
+#include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "media/mojo/interfaces/decryptor.mojom.h"
 #include "mojo/shell/public/cpp/connect.h"
 
 namespace media {
 
 MojoDecryptor::MojoDecryptor(interfaces::DecryptorPtr remote_decryptor)
     : remote_decryptor_(std::move(remote_decryptor)), weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
   CreateDataPipes();
 }
@@ skipping 148 matching lines @@
       << __FUNCTION__ << "(" << status << ")";
   DVLOG_IF(3, status == interfaces::Decryptor::Status::SUCCESS) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (video_frame.is_null()) {
     video_decode_cb.Run(static_cast<Decryptor::Status>(status), nullptr);
     return;
   }
 
   scoped_refptr<VideoFrame> frame(video_frame.To<scoped_refptr<VideoFrame>>());
+
+  // If using shared memory, ensure that ReleaseSharedBuffer() is called when
+  // |frame| is destroyed.
+  if (frame->storage_type() == VideoFrame::STORAGE_MOJO_SHARED_BUFFER) {
+    MojoSharedBufferVideoFrame* mojo_frame =
+        static_cast<MojoSharedBufferVideoFrame*>(frame.get());
+    mojo_frame->SetMojoSharedBufferDoneCB(base::Bind(
+        &MojoDecryptor::ReleaseSharedBuffer, weak_factory_.GetWeakPtr()));
+  }
+
   video_decode_cb.Run(static_cast<Decryptor::Status>(status), frame);
 }
 
+void MojoDecryptor::ReleaseSharedBuffer(mojo::ScopedSharedBufferHandle buffer,
+                                        size_t buffer_size) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  remote_decryptor_->ReleaseSharedBuffer(std::move(buffer), buffer_size);
+}
+
 void MojoDecryptor::CreateDataPipes() {
   // Allocate DataPipe size based on video content. Video can get quite large;
   // at 4K, VP9 delivers packets which are ~1MB in size; so allow for 50%
   // headroom.
   MojoCreateDataPipeOptions options;
   options.struct_size = sizeof(MojoCreateDataPipeOptions);
   options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
   options.element_num_bytes = 1;
   options.capacity_num_bytes = 1.5 * (1024 * 1024);
 
@@ skipping 45 matching lines @@
   uint32_t num_bytes = base::checked_cast<uint32_t>(media_buffer->data_size());
   DCHECK_GT(num_bytes, 0u);
   CHECK_EQ(ReadDataRaw(consumer_handle_.get(), media_buffer->writable_data(),
                        &num_bytes, MOJO_READ_DATA_FLAG_ALL_OR_NONE),
            MOJO_RESULT_OK);
   CHECK_EQ(num_bytes, static_cast<uint32_t>(media_buffer->data_size()));
   return media_buffer;
 }
 
 }  // namespace media