media: Implement MojoVideoDecoder::CanReadWithoutStalling().

media/mojo/services/mojo_video_decoder_service.cc

 // Copyright 2016 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_video_decoder_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/optional.h"
@@ skipping 18 matching lines @@
 }
 
 MojoVideoDecoderService::~MojoVideoDecoderService() {}
 
 void MojoVideoDecoderService::Construct(
     mojom::VideoDecoderClientAssociatedPtrInfo client,
     mojo::ScopedDataPipeConsumerHandle decoder_buffer_pipe,
     mojom::CommandBufferIdPtr command_buffer_id) {
   DVLOG(1) << __func__;
 
-  // TODO(sandersd): Close the channel.
-  if (decoder_)
+  if (decoder_) {
+    // TODO(sandersd): Close the channel.
     return;
+  }
 
   decoder_ = mojo_media_client_->CreateVideoDecoder(
       base::ThreadTaskRunnerHandle::Get(), std::move(command_buffer_id),
       base::Bind(&MojoVideoDecoderService::OnDecoderOutput, weak_this_));
 
   client_.Bind(std::move(client));
 
   mojo_decoder_buffer_reader_.reset(
       new MojoDecoderBufferReader(std::move(decoder_buffer_pipe)));
 }
@@ skipping 47 matching lines @@
     bool success) {
   DVLOG(1) << __func__;
   DCHECK(decoder_);
   callback.Run(success, decoder_->NeedsBitstreamConversion(),
                decoder_->GetMaxDecodeRequests());
 }
 
 void MojoVideoDecoderService::OnDecoderRead(
     const DecodeCallback& callback,
     scoped_refptr<DecoderBuffer> buffer) {
-  // TODO(sandersd): Close the channel.
   if (!buffer) {
+    // TODO(sandersd): Close the channel.
     callback.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   decoder_->Decode(
       buffer, base::Bind(&MojoVideoDecoderService::OnDecoderDecoded, weak_this_,
                          callback));
 }
 
 void MojoVideoDecoderService::OnDecoderDecoded(const DecodeCallback& callback,
                                                DecodeStatus status) {
   DVLOG(2) << __func__;
-  DCHECK(decoder_);
-  DCHECK(decoder_->CanReadWithoutStalling());
   callback.Run(status);
 }
 
 void MojoVideoDecoderService::OnDecoderReset(const ResetCallback& callback) {
   DVLOG(1) << __func__;
   callback.Run();
 }
 
 void MojoVideoDecoderService::OnDecoderOutput(
     MojoMediaClient::ReleaseMailboxCB release_cb,
     const scoped_refptr<VideoFrame>& frame) {
   DVLOG(2) << __func__;
   DCHECK(client_);
+  DCHECK(decoder_);
 
   base::Optional<base::UnguessableToken> release_token;
   if (release_cb) {
     release_token = base::UnguessableToken::Create();
     release_mailbox_cbs_[*release_token] = std::move(release_cb);
   }
 
-  client_->OnVideoFrameDecoded(frame, std::move(release_token));
+  client_->OnVideoFrameDecoded(frame, decoder_->CanReadWithoutStalling(),
+                               std::move(release_token));
 }
 
 void MojoVideoDecoderService::OnReleaseMailbox(
     const base::UnguessableToken& release_token,
     const gpu::SyncToken& release_sync_token) {
   DVLOG(2) << __func__;
 
   // TODO(sandersd): Is it a serious error for the client to call
   // OnReleaseMailbox() with an invalid |release_token|?
   auto it = release_mailbox_cbs_.find(release_token);
   if (it == release_mailbox_cbs_.end())
     return;
 
   MojoMediaClient::ReleaseMailboxCB cb = std::move(it->second);
   release_mailbox_cbs_.erase(it);
   std::move(cb).Run(release_sync_token);
 }
 
 }  // namespace media